Improved LSP support

Cargo.lock

···
 ]
 
 [[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
 name = "displaydoc"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
 
 [[package]]
+name = "libredox"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
+dependencies = [
+ "bitflags 2.9.4",
+ "libc",
+]
+
+[[package]]
 name = "linked-hash-map"
 version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 name = "mlf-lsp"
 version = "0.1.0"
 dependencies = [
+ "dirs",
+ "include_dir",
  "mlf-diagnostics",
  "mlf-lang",
  "serde",
···
 ]
 
 [[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
 name = "owo-colors"
 version = "4.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
  "bitflags 2.9.4",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom 0.2.16",
+ "libredox",
+ "thiserror 1.0.69",
 ]
 
 [[package]]

mlf-cli/src/fetch.rs

···
 }
 
 #[derive(Debug, Deserialize)]
-struct AtProtoRepoListRecords {
-    records: Vec<AtProtoRecord>,
-}
-
-#[derive(Debug, Deserialize)]
 struct AtProtoRecord {
     uri: String,
     value: serde_json::Value,
···
         return Ok(());
     }
 
-    // Extract authority from NSID (e.g., "place.stream" from "place.stream.key")
-    let authority = extract_authority(nsid_pattern)?;
+    // Extract authority and name segments from NSID
+    // For "app.bsky.actor.profile", authority is "app.bsky", name is "actor.profile"
+    // For DNS lookup, we need "_lexicon.actor.bsky.app"
+    let (authority, name_segments) = extract_authority_and_name(nsid_pattern)?;
     println!("Fetching lexicons for pattern: {}", nsid);
 
     // Step 1: DNS TXT lookup
-    let did = resolve_lexicon_did(&authority)?;
+    let did = resolve_lexicon_did(&authority, &name_segments)?;
     println!("  → Resolved DID: {}", did);
 
     // Step 2: Query ATProto repo for lexicon schemas
···
         // Match against pattern
         let matches = if is_wildcard {
             // Wildcard: match all records starting with the pattern
-            record_nsid.starts_with(nsid_pattern) && record_nsid.len() > nsid_pattern.len()
+            // For "app.bsky.actor.*", nsid_pattern is "app.bsky.actor"
+            // Should match "app.bsky.actor.defs", "app.bsky.actor.profile", etc.
+            let starts_with_pattern = record_nsid.starts_with(nsid_pattern);
+            let has_more_segments = record_nsid.len() > nsid_pattern.len();
+            let is_direct_child = if starts_with_pattern && has_more_segments {
+                // Check if the next character after the pattern is a dot
+                record_nsid.chars().nth(nsid_pattern.len()) == Some('.')
+            } else {
+                false
+            };
+
+            starts_with_pattern && has_more_segments && is_direct_child
         } else {
             // Specific: exact match only
             record_nsid == nsid
···
 
     let parts: Vec<&str> = nsid_base.split('.').collect();
 
-    // NSID must have at least 3 segments (authority + name)
-    // e.g., "place.stream.key" or "place.stream.*"
-    if parts.len() < 3 {
+    // NSID must have at least 2 segments (authority)
+    // e.g., "place.stream", "place.stream.key", or "place.stream.*"
+    if parts.len() < 2 {
         return Err(FetchError::InvalidNsid(format!(
-            "NSID must have at least 3 segments or use wildcard (e.g., 'place.stream.key' or 'place.stream.*'): {}",
+            "NSID must have at least 2 segments (e.g., 'place.stream' or 'com.atproto.repo.strongRef'): {}",
             nsid
         )));
     }
···
     Ok(())
 }
 
-fn extract_authority(nsid_pattern: &str) -> Result<String, FetchError> {
+fn extract_authority_and_name(nsid_pattern: &str) -> Result<(String, String), FetchError> {
     // NSID format: authority.name(.name)*
-    // For "place.stream.key", authority is "place.stream"
-    // Typically authority is the first 2 segments (reversed domain)
+    // For "place.stream.key", authority is "place.stream" (first 2), name is "key"
+    // For "app.bsky.actor.profile", authority is "app.bsky" (first 2), name is "actor.profile"
     let parts: Vec<&str> = nsid_pattern.split('.').collect();
 
     if parts.len() < 2 {
···
         )));
     }
 
-    // Take first 2 segments as authority (reversed domain)
-    Ok(format!("{}.{}", parts[0], parts[1]))
+    // Authority is first 2 segments (reversed domain)
+    let authority = format!("{}.{}", parts[0], parts[1]);
+
+    // Name segments are everything after the authority
+    let name_segments = if parts.len() > 2 {
+        parts[2..].join(".")
+    } else {
+        String::new()
+    };
+
+    Ok((authority, name_segments))
 }
 
-fn resolve_lexicon_did(authority: &str) -> Result<String, FetchError> {
-    // Reverse the authority for DNS lookup
-    // "stream.place" -> "place.stream" -> "_lexicon.place.stream"
-    let parts: Vec<&str> = authority.split('.').collect();
-    let reversed_parts: Vec<&str> = parts.iter().rev().copied().collect();
-    let dns_name = format!("_lexicon.{}", reversed_parts.join("."));
+fn resolve_lexicon_did(authority: &str, name_segments: &str) -> Result<String, FetchError> {
+    // Reverse the authority for DNS lookup and prepend name segments
+    // For "app.bsky" + "actor": "_lexicon.actor.bsky.app"
+    // For "place.stream" + "key": "_lexicon.key.stream.place"
+    let auth_parts: Vec<&str> = authority.split('.').collect();
+    let reversed_auth: Vec<&str> = auth_parts.iter().rev().copied().collect();
+
+    let dns_name = if name_segments.is_empty() {
+        // No name segments, just use reversed authority
+        // For "place.stream": "_lexicon.stream.place"
+        format!("_lexicon.{}", reversed_auth.join("."))
+    } else {
+        // Prepend name segments before reversed authority
+        // For "app.bsky" + "actor": "_lexicon.actor.bsky.app"
+        format!("_lexicon.{}.{}", name_segments, reversed_auth.join("."))
+    };
 
     println!("  Looking up DNS TXT record: {}", dns_name);
 
···
 fn fetch_lexicon_records(did: &str) -> Result<Vec<AtProtoRecord>, FetchError> {
     // Query the ATProto repo for records in com.atproto.lexicon.schema collection
     // We need to use the repo.listRecords XRPC endpoint
+    // Note: This API is paginated, so we need to fetch all pages
 
     // First, resolve the DID to a PDS endpoint
     let pds_url = resolve_did_to_pds(did)?;
 
     println!("  → Using PDS: {}", pds_url);
 
-    // Query listRecords endpoint
-    let url = format!(
-        "{}/xrpc/com.atproto.repo.listRecords?repo={}&collection=com.atproto.lexicon.schema",
-        pds_url, did
-    );
+    let mut all_records = Vec::new();
+    let mut cursor: Option<String> = None;
+    let mut page_num = 1;
+
+    loop {
+        // Build URL with optional cursor
+        let url = if let Some(ref c) = cursor {
+            format!(
+                "{}/xrpc/com.atproto.repo.listRecords?repo={}&collection=com.atproto.lexicon.schema&cursor={}",
+                pds_url, did, c
+            )
+        } else {
+            format!(
+                "{}/xrpc/com.atproto.repo.listRecords?repo={}&collection=com.atproto.lexicon.schema",
+                pds_url, did
+            )
+        };
+
+        println!("  Fetching lexicon records (page {})...", page_num);
+
+        let response = reqwest::blocking::get(&url)
+            .map_err(|e| FetchError::HttpError(format!("Failed to fetch records: {}", e)))?;
+
+        if !response.status().is_success() {
+            return Err(FetchError::HttpError(format!(
+                "HTTP {} when fetching records",
+                response.status()
+            )));
+        }
+
+        let mut list_response: serde_json::Value = response
+            .json()
+            .map_err(|e| FetchError::HttpError(format!("Failed to parse response: {}", e)))?;
+
+        // Extract records
+        if let Some(records_array) = list_response.get_mut("records") {
+            if let Some(records) = records_array.as_array_mut() {
+                for record_value in records.drain(..) {
+                    let record: AtProtoRecord = serde_json::from_value(record_value)
+                        .map_err(|e| FetchError::HttpError(format!("Failed to parse record: {}", e)))?;
+                    all_records.push(record);
+                }
+            }
+        }
 
-    println!("  Fetching lexicon records from: {}", url);
+        // Check for cursor to continue pagination
+        cursor = list_response.get("cursor")
+            .and_then(|c| c.as_str())
+            .map(|s| s.to_string());
 
-    let response = reqwest::blocking::get(&url)
-        .map_err(|e| FetchError::HttpError(format!("Failed to fetch records: {}", e)))?;
+        if cursor.is_none() {
+            break;
+        }
 
-    if !response.status().is_success() {
-        return Err(FetchError::HttpError(format!(
-            "HTTP {} when fetching records",
-            response.status()
-        )));
+        page_num += 1;
     }
 
-    let list_response: AtProtoRepoListRecords = response
-        .json()
-        .map_err(|e| FetchError::HttpError(format!("Failed to parse response: {}", e)))?;
-
-    Ok(list_response.records)
+    Ok(all_records)
 }
 
 fn resolve_did_to_pds(did: &str) -> Result<String, FetchError> {

mlf-lang/src/error.rs

···
     InvalidIdentifier { name: String, span: Span },
 }
 
+impl ParseError {
+    pub fn message(&self) -> String {
+        match self {
+            ParseError::Syntax { message, .. } => message.clone(),
+            ParseError::UnexpectedEof { expected, .. } => {
+                alloc::format!("Unexpected end of file, expected {}", expected)
+            }
+            ParseError::InvalidIdentifier { name, .. } => {
+                alloc::format!("Invalid identifier: {}", name)
+            }
+        }
+    }
+
+    pub fn span(&self) -> Option<Span> {
+        match self {
+            ParseError::Syntax { span, .. } => Some(*span),
+            ParseError::UnexpectedEof { span, .. } => Some(*span),
+            ParseError::InvalidIdentifier { span, .. } => Some(*span),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum ValidationError {
     DuplicateDefinition { name: String, first_span: Span, second_span: Span, module_namespace: String },

mlf-lang/src/parser.rs

···
         segments.push(self.parse_ident_or_keyword()?);
 
         while matches!(self.current().token, LexToken::Dot) {
+            // Check if next token is LeftBrace (for use namespace.{ syntax)
+            if let Some(next) = self.peek(1) {
+                if matches!(next.token, LexToken::LeftBrace) {
+                    break;
+                }
+            }
             self.advance();
             segments.push(self.parse_ident_or_keyword()?);
         }
···
         let start = self.expect(LexToken::Use)?;
         let path = self.parse_path()?;
 
-        let imports = if matches!(self.current().token, LexToken::LeftBrace) {
-            // use namespace { items }
-            self.advance(); // consume {
+        let imports = if matches!(self.current().token, LexToken::Dot) {
+            // use namespace.{ items }
+            self.advance(); // consume .
+            self.expect(LexToken::LeftBrace)?; // consume {
             let mut items = Vec::new();
 
             while !matches!(self.current().token, LexToken::RightBrace) {
···
                 let span = path.span;
                 Type::Reference { path, span }
             }
-            LexToken::LeftBracket => {
-                self.advance();
-                let inner = self.parse_type()?;
-                let end = self.expect(LexToken::RightBracket)?;
-                Type::Array {
-                    inner: alloc::boxed::Box::new(inner),
-                    span: Span::new(start, end.end),
-                }
-            }
             LexToken::LeftBrace => {
                 self.advance();
                 let mut fields = Vec::new();
···
 
     #[test]
     fn test_parse_array_type() {
-        let input = "inline type userList = [user];";
+        let input = "inline type userList = user[];";
         let result = parse_lexicon(input);
         assert!(result.is_ok());
         let lexicon = result.unwrap();
···
 
     #[test]
     fn test_parse_use_with_main() {
-        let input = "use com.example.thread { main };";
+        let input = "use com.example.thread.{ main };";
         let result = parse_lexicon(input);
         assert!(result.is_ok());
         let lexicon = result.unwrap();
···
 
     #[test]
     fn test_parse_use_with_main_and_alias() {
-        let input = "use com.example.thread { main as ThreadRecord };";
+        let input = "use com.example.thread.{ main as ThreadRecord };";
         let result = parse_lexicon(input);
         assert!(result.is_ok());
         let lexicon = result.unwrap();
···
 
     #[test]
     fn test_parse_use_with_multiple_items() {
-        let input = "use com.example { main, foo, bar as Baz };";
+        let input = "use com.example.{ main, foo, bar as Baz };";
         let result = parse_lexicon(input);
         assert!(result.is_ok());
         let lexicon = result.unwrap();

mlf-lang/src/workspace.rs

···
+use alloc::collections::{BTreeMap, BTreeSet};
 use alloc::string::String;
 use alloc::vec::Vec;
-use alloc::collections::BTreeMap;
 use crate::{ast::*, error::{ValidationError, ValidationErrors}, span::Span};
 
 #[derive(Debug, Clone, PartialEq)]
···
 #[derive(Debug, Clone, PartialEq, Default)]
 struct ImportTable {
     mappings: BTreeMap<String, ImportedSymbol>,
+    used_imports: BTreeSet<String>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
 struct ImportedSymbol {
     original_path: Vec<String>,
     local_name: String,
+    span: Span,
 }
 
 #[derive(Debug, Clone, PartialEq)]
···
             errors.append(&mut import_errors);
         }
 
-        let modules: Vec<(String, Module)> = self.modules.iter()
-            .map(|(k, v)| (k.clone(), v.clone()))
-            .collect();
+        let namespaces: Vec<String> = self.modules.keys().cloned().collect();
 
-        for (namespace, module) in modules {
+        for namespace in namespaces {
+            let module = self.modules[&namespace].clone();
             if let Err(mut module_errors) = self.resolve_module(&namespace, &module) {
                 errors.append(&mut module_errors);
             }
···
             return Err(errors);
         }
 
+        // Check for unused imports
+        if let Err(mut unused_import_errors) = self.check_unused_imports() {
+            errors.append(&mut unused_import_errors);
+        }
+
         if let Err(mut typecheck_errors) = self.typecheck() {
             errors.append(&mut typecheck_errors);
+        }
+
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors)
+        }
+    }
+
+    fn check_unused_imports(&self) -> Result<(), ValidationErrors> {
+        let mut errors = ValidationErrors::new();
+
+        for (namespace, module) in &self.modules {
+            // Skip prelude module
+            if namespace == "prelude" {
+                continue;
+            }
+
+            for (local_name, imported) in &module.imports.mappings {
+                if !module.imports.used_imports.contains(local_name) {
+                    errors.push(ValidationError::UnusedImport {
+                        name: local_name.clone(),
+                        span: imported.span,
+                        module_namespace: namespace.clone(),
+                    });
+                }
+            }
         }
 
         if errors.is_empty() {
···
         false
     }
 
+    /// Get all imported types for a given namespace
+    /// Returns a vector of (local_name, original_path) tuples
+    pub fn get_imports(&self, namespace: &str) -> Vec<(String, Vec<String>)> {
+        if let Some(module) = self.modules.get(namespace) {
+            module.imports.mappings.iter()
+                .map(|(local_name, imported)| {
+                    (local_name.clone(), imported.original_path.clone())
+                })
+                .collect()
+        } else {
+            Vec::new()
+        }
+    }
+
+    /// Get all type names defined in a given namespace
+    /// Returns a vector of type names
+    pub fn get_namespace_types(&self, namespace: &str) -> Vec<String> {
+        if let Some(module) = self.modules.get(namespace) {
+            module.symbols.types.keys().cloned().collect()
+        } else {
+            Vec::new()
+        }
+    }
+
+    /// Get all namespaces in the workspace
+    /// Returns a vector of namespace strings
+    pub fn get_all_namespaces(&self) -> Vec<String> {
+        self.modules.keys().cloned().collect()
+    }
+
+    /// Get all fully-qualified type references (NSIDs) in the workspace
+    /// Returns a vector of (nsid, namespace, typename) tuples
+    /// Example: ("com.atproto.repo.strongRef", "com.atproto.repo", "strongRef")
+    pub fn get_all_nsids(&self) -> Vec<(String, String, String)> {
+        let mut nsids = Vec::new();
+
+        for (namespace, module) in &self.modules {
+            // Skip prelude since it's auto-imported
+            if namespace == "prelude" {
+                continue;
+            }
+
+            for type_name in module.symbols.types.keys() {
+                let nsid = if namespace.is_empty() {
+                    type_name.clone()
+                } else {
+                    alloc::format!("{}.{}", namespace, type_name)
+                };
+                nsids.push((nsid, namespace.clone(), type_name.clone()));
+            }
+        }
+
+        nsids
+    }
+
     /// Resolve a type reference to its actual namespace
     /// Returns the namespace where the type is defined, or None if not found
     pub fn resolve_reference_namespace(&self, path: &Path, current_namespace: &str) -> Option<String> {
···
                                 .chain(core::iter::once(type_name.clone()))
                                 .collect(),
                             local_name: type_name.clone(),
+                            span: use_stmt.path.span,
                         };
                         (type_name.clone(), imported)
                     })
···
                         ImportedSymbol {
                             original_path,
                             local_name,
+                            span: item.name.span,
                         },
                     ));
                 }
···
         }
     }
 
-    fn resolve_module(&self, namespace: &str, module: &Module) -> Result<(), ValidationErrors> {
+    fn resolve_module(&mut self, namespace: &str, module: &Module) -> Result<(), ValidationErrors> {
         let mut errors = ValidationErrors::new();
 
         for item in &module.lexicon.items {
···
         }
     }
 
-    fn resolve_item(&self, namespace: &str, item: &Item) -> Result<(), ValidationErrors> {
+    fn resolve_item(&mut self, namespace: &str, item: &Item) -> Result<(), ValidationErrors> {
         match item {
             Item::Record(r) => self.resolve_record(namespace, r),
             Item::InlineType(i) => self.resolve_inline_type(namespace, i),
···
         }
     }
 
-    fn resolve_record(&self, namespace: &str, record: &Record) -> Result<(), ValidationErrors> {
+    fn resolve_record(&mut self, namespace: &str, record: &Record) -> Result<(), ValidationErrors> {
         let mut errors = ValidationErrors::new();
 
         for field in &record.fields {
···
         }
     }
 
-    fn resolve_inline_type(&self, namespace: &str, inline_type: &InlineType) -> Result<(), ValidationErrors> {
+    fn resolve_inline_type(&mut self, namespace: &str, inline_type: &InlineType) -> Result<(), ValidationErrors> {
         self.resolve_type(namespace, &inline_type.ty)
     }
 
-    fn resolve_def_type(&self, namespace: &str, def_type: &DefType) -> Result<(), ValidationErrors> {
+    fn resolve_def_type(&mut self, namespace: &str, def_type: &DefType) -> Result<(), ValidationErrors> {
         self.resolve_type(namespace, &def_type.ty)
     }
 
-    fn resolve_query(&self, namespace: &str, query: &Query) -> Result<(), ValidationErrors> {
+    fn resolve_query(&mut self, namespace: &str, query: &Query) -> Result<(), ValidationErrors> {
         let mut errors = ValidationErrors::new();
 
         for param in &query.params {
···
         }
     }
 
-    fn resolve_procedure(&self, namespace: &str, procedure: &Procedure) -> Result<(), ValidationErrors> {
+    fn resolve_procedure(&mut self, namespace: &str, procedure: &Procedure) -> Result<(), ValidationErrors> {
         let mut errors = ValidationErrors::new();
 
         for param in &procedure.params {
···
         }
     }
 
-    fn resolve_subscription(&self, namespace: &str, subscription: &Subscription) -> Result<(), ValidationErrors> {
+    fn resolve_subscription(&mut self, namespace: &str, subscription: &Subscription) -> Result<(), ValidationErrors> {
         let mut errors = ValidationErrors::new();
 
         for param in &subscription.params {
···
         }
     }
 
-    fn resolve_type(&self, namespace: &str, ty: &Type) -> Result<(), ValidationErrors> {
+    fn resolve_type(&mut self, namespace: &str, ty: &Type) -> Result<(), ValidationErrors> {
         match ty {
             Type::Primitive { .. } | Type::Unknown { .. } => Ok(()),
             Type::Reference { path, span } => {
···
         }
     }
 
-    fn resolve_reference(&self, current_namespace: &str, path: &Path, span: Span) -> Result<(), ValidationErrors> {
+    fn resolve_reference(&mut self, current_namespace: &str, path: &Path, span: Span) -> Result<(), ValidationErrors> {
         let full_path = path.to_string();
 
         if path.segments.len() == 1 {
···
                 }
 
                 if module.imports.mappings.contains_key(name) {
+                    // Mark this import as used
+                    if let Some(module_mut) = self.modules.get_mut(current_namespace) {
+                        module_mut.imports.used_imports.insert(name.clone());
+                    }
                     return Ok(());
                 }
             }
···
         let lexicon = parse_lexicon(input).unwrap();
         let result = ws.add_module("com.example.thread".into(), lexicon);
         assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_unused_import() {
+        let mut ws = Workspace::new();
+
+        let a = parse_lexicon("record foo {}").unwrap();
+        ws.add_module("a".into(), a).unwrap();
+
+        let b = parse_lexicon("use a.foo as Foo; record bar {}").unwrap();
+        ws.add_module("b".into(), b).unwrap();
+
+        let result = ws.resolve();
+        assert!(result.is_err());
+        let errors = result.unwrap_err();
+        assert!(errors.errors.iter().any(|e| matches!(e, ValidationError::UnusedImport { .. })));
+    }
+
+    #[test]
+    fn test_used_import() {
+        let mut ws = Workspace::new();
+
+        let a = parse_lexicon("record foo {}").unwrap();
+        ws.add_module("a".into(), a).unwrap();
+
+        let b = parse_lexicon("use a.foo as Foo; record bar { baz: Foo, }").unwrap();
+        ws.add_module("b".into(), b).unwrap();
+
+        let result = ws.resolve();
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_unused_import_all() {
+        let mut ws = Workspace::new();
+
+        let a = parse_lexicon("record foo {} record bar {}").unwrap();
+        ws.add_module("a".into(), a).unwrap();
+
+        let b = parse_lexicon("use a; record baz {}").unwrap();
+        ws.add_module("b".into(), b).unwrap();
+
+        let result = ws.resolve();
+        assert!(result.is_err());
+        let errors = result.unwrap_err();
+        // Should have 2 unused import errors (foo and bar)
+        let unused_count = errors.errors.iter().filter(|e| matches!(e, ValidationError::UnusedImport { .. })).count();
+        assert_eq!(unused_count, 2);
     }
 }

mlf-lsp/Cargo.toml

···
 mlf-lang = { path = "../mlf-lang" }
 mlf-diagnostics = { path = "../mlf-diagnostics" }
 
+# For accessing embedded std library
+include_dir = "0.7"
+dirs = "5.0"
+
 # LSP
 tower-lsp = "0.20"
 tokio = { version = "1", features = ["full"] }

mlf-lsp/src/context.rs

···
+/// Context detection for smart completions
+
+#[derive(Debug, PartialEq)]
+pub enum CompletionContext {
+    /// Top-level (suggesting keywords like record, query, etc.)
+    TopLevel,
+    /// After "use" keyword (suggesting module paths)
+    UseStatement,
+    /// In a type position (field type, parameter type, etc.)
+    TypePosition,
+    /// Inside constrained { } block
+    ConstraintBlock,
+    /// Unknown context
+    Unknown,
+}
+
+/// Detect the completion context based on the text before the cursor
+pub fn detect_context(text_before_cursor: &str) -> CompletionContext {
+    // Check if we're in a use statement (check before trimming!)
+    if let Some(last_line) = text_before_cursor.lines().last() {
+        let last_line = last_line.trim_start(); // Only trim left side
+
+        // "use ", "use com.", "use com.atproto."
+        if last_line.starts_with("use ") && !last_line.contains(';') {
+            return CompletionContext::UseStatement;
+        }
+    }
+
+    let trimmed = text_before_cursor.trim_end();
+
+    // Check if we're inside a constrained block
+    // Count open and closed braces after "constrained"
+    if let Some(constrained_pos) = trimmed.rfind("constrained") {
+        let after_constrained = &trimmed[constrained_pos..];
+        let open_braces = after_constrained.matches('{').count();
+        let close_braces = after_constrained.matches('}').count();
+
+        if open_braces > close_braces {
+            return CompletionContext::ConstraintBlock;
+        }
+    }
+
+    // Check if we're in a type position (after : or after field name)
+    // Look for patterns like "field:" or "field :" or "field: " or "(param:"
+    if trimmed.ends_with(':') || trimmed.ends_with(": ") {
+        return CompletionContext::TypePosition;
+    }
+
+    // Check if the last "word" before cursor looks like we're after a colon
+    // This handles "field:string" where cursor is after string
+    let words: Vec<&str> = trimmed.split_whitespace().collect();
+    if let Some(last_word) = words.last() {
+        if last_word.contains(':') && !last_word.ends_with(':') {
+            // We're potentially completing a type that was already started
+            return CompletionContext::TypePosition;
+        }
+    }
+
+    // Check if we're in a record/query/procedure body (inside braces or parens)
+    let open_braces = trimmed.matches('{').count();
+    let close_braces = trimmed.matches('}').count();
+    let open_parens = trimmed.matches('(').count();
+    let close_parens = trimmed.matches(')').count();
+
+    if (open_braces > close_braces) || (open_parens > close_parens) {
+        // We're inside a block - could be fields or parameters
+        // If the line contains a colon, we're likely after it (type position)
+        if let Some(last_line) = trimmed.lines().last() {
+            if last_line.contains(':') {
+                return CompletionContext::TypePosition;
+            }
+        }
+        // Otherwise, might be starting a new field (but not type position yet)
+        return CompletionContext::Unknown;
+    }
+
+    // Default to top-level
+    CompletionContext::TopLevel
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_use_statement() {
+        assert_eq!(
+            detect_context("use "),
+            CompletionContext::UseStatement
+        );
+        assert_eq!(
+            detect_context("use com."),
+            CompletionContext::UseStatement
+        );
+        assert_eq!(
+            detect_context("use com.atproto."),
+            CompletionContext::UseStatement
+        );
+    }
+
+    #[test]
+    fn test_type_position() {
+        assert_eq!(
+            detect_context("record foo {\n  bar:"),
+            CompletionContext::TypePosition
+        );
+        assert_eq!(
+            detect_context("record foo {\n  bar: "),
+            CompletionContext::TypePosition
+        );
+    }
+
+    #[test]
+    fn test_constraint_block() {
+        assert_eq!(
+            detect_context("field: string constrained {"),
+            CompletionContext::ConstraintBlock
+        );
+        assert_eq!(
+            detect_context("field: string constrained {\n  maxLength: 100,"),
+            CompletionContext::ConstraintBlock
+        );
+    }
+
+    #[test]
+    fn test_top_level() {
+        assert_eq!(detect_context(""), CompletionContext::TopLevel);
+        assert_eq!(detect_context("rec"), CompletionContext::TopLevel);
+    }
+}

mlf-lsp/src/lib.rs

···
+pub mod context;
+pub mod namespace_completion;
 pub mod server;
 pub mod utils;
 

mlf-lsp/src/main.rs

···
 
 #[tokio::main]
 async fn main() {
-    // Initialize logging
+    // Set up panic hook to log panics
+    std::panic::set_hook(Box::new(|panic_info| {
+        eprintln!("LSP PANIC: {:?}", panic_info);
+        if let Some(location) = panic_info.location() {
+            eprintln!("  at {}:{}:{}", location.file(), location.line(), location.column());
+        }
+        if let Some(message) = panic_info.payload().downcast_ref::<&str>() {
+            eprintln!("  message: {}", message);
+        } else if let Some(message) = panic_info.payload().downcast_ref::<String>() {
+            eprintln!("  message: {}", message);
+        }
+    }));
+
+    // Initialize logging with debug level
     tracing_subscriber::fmt()
-        .with_env_filter(EnvFilter::from_default_env())
+        .with_env_filter(
+            EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| EnvFilter::new("debug"))
+        )
         .with_writer(std::io::stderr)
         .init();
 
···
 
     let (service, socket) = LspService::new(|client| MlfLanguageServer::new(client));
 
+    tracing::info!("Server created, starting to serve...");
+
     Server::new(stdin, stdout, socket).serve(service).await;
+
+    tracing::info!("Server stopped");
 }

mlf-lsp/src/namespace_completion.rs

···
+/// Shared namespace path completion logic
+///
+/// This module provides utilities for completing namespace paths in both
+/// `use` statements and type positions (e.g., `com.atproto.repo.strongRef`).
+
+use std::collections::{HashMap, HashSet};
+use tower_lsp::lsp_types::*;
+use mlf_lang::Workspace;
+
+use crate::server::DocumentState;
+
+/// Complete a namespace path based on a partial input
+///
+/// This function handles intelligent namespace completion:
+/// - If partial_path is empty: suggests top-level namespaces only (e.g., "com", "app")
+/// - If partial_path ends with '.': suggests next-level segments or types in that namespace
+/// - Otherwise: suggests matching namespace extensions
+///
+/// Returns a vector of completion items with proper text edits
+pub fn complete_namespace_path(
+    workspace: &Workspace,
+    documents: &HashMap<Url, DocumentState>,
+    current_namespace: Option<&String>,
+    partial_path: &str,
+    has_trailing_dot: bool,
+    replace_start: Position,
+    replace_end: Position,
+    _full_document_text: &str,
+    suggest_types_after_dot: bool, // Whether to suggest { }, *, and types after a trailing dot
+) -> Vec<CompletionItem> {
+    let mut completions = vec![];
+    let mut seen = HashSet::new();
+
+    // If user typed "namespace." - suggest items from that namespace (and { } and *)
+    if has_trailing_dot && !partial_path.is_empty() && suggest_types_after_dot {
+        let types = workspace.get_namespace_types(partial_path);
+
+        if !types.is_empty() {
+            // Suggest wildcard
+            completions.push(CompletionItem {
+                label: "*".to_string(),
+                kind: Some(CompletionItemKind::KEYWORD),
+                detail: Some("Import all types".to_string()),
+                insert_text: Some("*".to_string()),
+                ..Default::default()
+            });
+
+            // Suggest braces for item list
+            completions.push(CompletionItem {
+                label: "{ }".to_string(),
+                kind: Some(CompletionItemKind::SNIPPET),
+                detail: Some("Import specific items".to_string()),
+                insert_text: Some("{ $0 }".to_string()),
+                insert_text_format: Some(InsertTextFormat::SNIPPET),
+                ..Default::default()
+            });
+
+            // Suggest individual types
+            for type_name in types {
+                completions.push(CompletionItem {
+                    label: type_name.clone(),
+                    kind: Some(CompletionItemKind::CLASS),
+                    detail: Some(format!("from {}", partial_path)),
+                    insert_text: Some(format!("{{ {} }}", type_name)),
+                    ..Default::default()
+                });
+            }
+        }
+    }
+
+    // Get all module namespaces from open documents
+    for (_, doc) in documents.iter() {
+        if let Some(ns) = &doc.namespace {
+            // Skip self
+            if Some(ns) == current_namespace {
+                continue;
+            }
+
+            // Skip prelude (it's auto-imported)
+            if ns == "prelude" {
+                continue;
+            }
+
+            // Determine what to suggest based on partial path
+            let suggestion = if partial_path.is_empty() {
+                // No path yet - suggest top-level modules only
+                ns.split('.').next().map(|s| s.to_string())
+            } else {
+                // Check if this namespace matches or extends the partial path
+                if ns.starts_with(partial_path) {
+                    // Full match - include it
+                    if ns == partial_path {
+                        Some(ns.clone())
+                    } else if ns.chars().nth(partial_path.len()) == Some('.') {
+                        // Namespace continues after partial path with a dot
+                        // Suggest the next level: com.atproto.server -> suggest "com.atproto" when partial is "com"
+                        let after_partial = &ns[partial_path.len() + 1..]; // Skip the dot
+                        if let Some(next_segment) = after_partial.split('.').next() {
+                            Some(format!("{}.{}", partial_path, next_segment))
+                        } else {
+                            None
+                        }
+                    } else {
+                        // Partial path is a prefix but not at a segment boundary
+                        None
+                    }
+                } else {
+                    None
+                }
+            };
+
+            if let Some(label) = suggestion {
+                if seen.insert(label.clone()) {
+                    let text_edit = TextEdit {
+                        range: Range {
+                            start: replace_start,
+                            end: replace_end,
+                        },
+                        new_text: label.clone(),
+                    };
+
+                    completions.push(CompletionItem {
+                        label: label.clone(),
+                        kind: Some(CompletionItemKind::MODULE),
+                        detail: Some("module".to_string()),
+                        text_edit: Some(CompletionTextEdit::Edit(text_edit)),
+                        ..Default::default()
+                    });
+                }
+            }
+        }
+    }
+
+    // If we're completing a path with a trailing dot, also suggest types from that namespace
+    if has_trailing_dot && !partial_path.is_empty() && !suggest_types_after_dot {
+        let types = workspace.get_namespace_types(partial_path);
+        for type_name in types {
+            let full_nsid = format!("{}.{}", partial_path, type_name);
+            if seen.insert(full_nsid.clone()) {
+                let text_edit = TextEdit {
+                    range: Range {
+                        start: replace_start,
+                        end: replace_end,
+                    },
+                    new_text: full_nsid.clone(),
+                };
+
+                completions.push(CompletionItem {
+                    label: full_nsid.clone(),
+                    kind: Some(CompletionItemKind::REFERENCE),
+                    detail: Some(format!("{} from {}", type_name, partial_path)),
+                    text_edit: Some(CompletionTextEdit::Edit(text_edit)),
+                    filter_text: Some(full_nsid.clone()),
+                    sort_text: Some(format!("a{}", type_name)), // Sort types first
+                    ..Default::default()
+                });
+            }
+        }
+    }
+
+    completions
+}

mlf-lsp/src/server.rs

···
 use tower_lsp::lsp_types::*;
 use tower_lsp::{Client, LanguageServer};
 
+use crate::context::{detect_context, CompletionContext as MlfCompletionContext};
+use crate::namespace_completion;
 use crate::utils::*;
 
 pub struct MlfLanguageServer {
···
     workspace: tokio::sync::RwLock<Option<Workspace>>,
 }
 
-struct DocumentState {
-    text: String,
-    lexicon: Option<Lexicon>,
-    namespace: Option<String>,
+pub struct DocumentState {
+    pub text: String,
+    pub lexicon: Option<Lexicon>,
+    pub namespace: Option<String>,
 }
 
 impl MlfLanguageServer {
···
     }
 
     async fn parse_document(&self, uri: &Url, text: &str) {
+        // Extract namespace from file path (always available, even on parse error)
+        let namespace = extract_namespace_from_uri(uri);
+
         // Parse the document
         match mlf_lang::parser::parse_lexicon(text) {
             Ok(lexicon) => {
-                // Extract namespace from file path
-                let namespace = extract_namespace_from_uri(uri);
-
                 // Store parsed state
                 self.documents.write().await.insert(
                     uri.clone(),
···
                     },
                 );
 
-                // Update workspace
-                self.update_workspace(uri, lexicon, namespace).await;
+                // Update workspace and get validation diagnostics
+                let mut diagnostics = self.update_workspace(uri, lexicon, namespace, text).await;
 
-                // Clear diagnostics on success
+                // Add read-only warning for std library files
+                if is_std_library_file(uri) {
+                    diagnostics.insert(0, Diagnostic {
+                        range: Range {
+                            start: Position { line: 0, character: 0 },
+                            end: Position { line: 0, character: 0 },
+                        },
+                        severity: Some(DiagnosticSeverity::INFORMATION),
+                        code: None,
+                        code_description: None,
+                        source: Some("mlf".to_string()),
+                        message: "This is a standard library file and should not be edited. Changes may be overwritten.".to_string(),
+                        related_information: None,
+                        tags: None,
+                        data: None,
+                    });
+                }
+
+                // Publish diagnostics (empty if no errors)
                 self.client
-                    .publish_diagnostics(uri.clone(), vec![], None)
+                    .publish_diagnostics(uri.clone(), diagnostics, None)
                     .await;
             }
             Err(err) => {
-                // Store failed state
+                // Even on parse error, try to extract partial information
+                // Parse individual top-level items and keep what works
+                let partial_lexicon = self.parse_partial_lexicon(text);
+
+                // Store partial state (with namespace so completion still works)
                 self.documents.write().await.insert(
                     uri.clone(),
                     DocumentState {
                         text: text.to_string(),
-                        lexicon: None,
-                        namespace: None,
+                        lexicon: partial_lexicon.clone(),
+                        namespace: namespace.clone(),
                     },
                 );
 
-                // Convert parse error to LSP diagnostic
-                let diagnostic = Diagnostic {
-                    range: Range {
-                        start: Position {
-                            line: 0,
-                            character: 0,
-                        },
-                        end: Position {
-                            line: 0,
-                            character: 0,
-                        },
-                    },
+                // Try to update workspace with partial lexicon if available
+                let mut diagnostics = if let Some(ref lex) = partial_lexicon {
+                    self.update_workspace(uri, lex.clone(), namespace, text).await
+                } else {
+                    vec![]
+                };
+
+                // Add parse error diagnostic
+                let error_range = if let Some(span) = err.span() {
+                    span_to_range(text, span)
+                } else {
+                    Range {
+                        start: Position { line: 0, character: 0 },
+                        end: Position { line: 0, character: 0 },
+                    }
+                };
+
+                diagnostics.push(Diagnostic {
+                    range: error_range,
                     severity: Some(DiagnosticSeverity::ERROR),
                     code: None,
                     code_description: None,
                     source: Some("mlf".to_string()),
-                    message: format!("{:?}", err),
+                    message: err.message(),
                     related_information: None,
                     tags: None,
                     data: None,
-                };
+                });
 
                 self.client
-                    .publish_diagnostics(uri.clone(), vec![diagnostic], None)
+                    .publish_diagnostics(uri.clone(), diagnostics, None)
                     .await;
             }
         }
     }
 
-    async fn update_workspace(&self, _uri: &Url, lexicon: Lexicon, namespace: Option<String>) {
+    /// Try to parse individual items from a document, skipping errors
+    /// This allows LSP features to work on the valid parts of a document
+    fn parse_partial_lexicon(&self, _text: &str) -> Option<Lexicon> {
+        // Split by top-level keywords and try to parse each section
+        // For now, just return None - a full implementation would parse
+        // line-by-line or use error recovery in the parser
+        // TODO: Implement proper error recovery
+        None
+    }
+
+    async fn update_workspace(&self, _uri: &Url, lexicon: Lexicon, namespace: Option<String>, text: &str) -> Vec<Diagnostic> {
+        let mut diagnostics = vec![];
+
         if let Some(ns) = namespace {
             let mut workspace_guard = self.workspace.write().await;
 
-            // Initialize workspace if needed
+            // Initialize workspace if needed (with full std library)
             if workspace_guard.is_none() {
                 match Workspace::with_std() {
-                    Ok(ws) => *workspace_guard = Some(ws),
+                    Ok(ws) => {
+                        // Populate document storage with std library files for navigation
+                        self.load_std_documents().await;
+                        *workspace_guard = Some(ws);
+                    }
                     Err(_) => {
-                        *workspace_guard = Some(Workspace::new());
+                        // Fallback to prelude if std loading fails
+                        match Workspace::with_prelude() {
+                            Ok(ws) => {
+                                self.load_prelude_document().await;
+                                *workspace_guard = Some(ws);
+                            }
+                            Err(_) => *workspace_guard = Some(Workspace::new()),
+                        }
                     }
                 }
             }
···
             // Add or update module in workspace
             if let Some(workspace) = workspace_guard.as_mut() {
                 let _ = workspace.add_module(ns.clone(), lexicon);
-                let _ = workspace.resolve();
+
+                // Resolve and collect validation errors
+                if let Err(errors) = workspace.resolve() {
+                    use mlf_lang::error::ValidationError;
+
+                    for error in errors.errors {
+                        // Only show diagnostics for the current file
+                        if mlf_diagnostics::get_error_module_namespace_str(&error) == ns {
+                            // Extract span and message from error variant
+                            let (span, message, is_unused) = match &error {
+                                ValidationError::DuplicateDefinition { name, second_span, .. } => {
+                                    (*second_span, format!("Duplicate definition: {}", name), false)
+                                }
+                                ValidationError::UndefinedReference { name, span, .. } => {
+                                    (*span, format!("Undefined reference: {}", name), false)
+                                }
+                                ValidationError::InvalidConstraint { message, span, .. } => {
+                                    (*span, format!("Invalid constraint: {}", message), false)
+                                }
+                                ValidationError::TypeMismatch { expected, found, span, .. } => {
+                                    (*span, format!("Type mismatch: expected {}, found {}", expected, found), false)
+                                }
+                                ValidationError::ConstraintTooPermissive { message, span, .. } => {
+                                    (*span, format!("Constraint too permissive: {}", message), false)
+                                }
+                                ValidationError::ReservedName { name, span, .. } => {
+                                    (*span, format!("Reserved name: {}", name), false)
+                                }
+                                ValidationError::AmbiguousMain { name, first_span, .. } => {
+                                    (*first_span, format!("Ambiguous main: {}", name), false)
+                                }
+                                ValidationError::MultipleMain { name, first_span, .. } => {
+                                    (*first_span, format!("Multiple @main annotations: {}", name), false)
+                                }
+                                ValidationError::ConflictNotAllowed { name, span, .. } => {
+                                    (*span, format!("Conflict not allowed: {}", name), false)
+                                }
+                                ValidationError::CircularImport { cycle, span, .. } => {
+                                    (*span, format!("Circular import: {}", cycle.join(" -> ")), false)
+                                }
+                                ValidationError::UnusedImport { name, span, .. } => {
+                                    (*span, format!("Unused import: {}", name), true)
+                                }
+                            };
+
+                            let range = span_to_range(text, span);
+
+                            diagnostics.push(Diagnostic {
+                                range,
+                                severity: Some(if is_unused { DiagnosticSeverity::HINT } else { DiagnosticSeverity::ERROR }),
+                                code: None,
+                                code_description: None,
+                                source: Some("mlf".to_string()),
+                                message,
+                                related_information: None,
+                                tags: if is_unused {
+                                    Some(vec![DiagnosticTag::UNNECESSARY])
+                                } else {
+                                    None
+                                },
+                                data: None,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+
+        diagnostics
+    }
+
+    async fn load_std_documents(&self) {
+        self.client
+            .log_message(MessageType::INFO, "Loading std library documents...")
+            .await;
+
+        // Use global ~/.mlf/lexicons/mlf/ directory (matches project structure)
+        let global_mlf_dir = dirs::home_dir()
+            .map(|h| h.join(".mlf"))
+            .unwrap_or_else(|| PathBuf::from(".mlf"));
+
+        let std_dir = global_mlf_dir.join("lexicons").join("mlf");
+
+        self.client
+            .log_message(MessageType::INFO, format!("Global MLF directory: {}", global_mlf_dir.display()))
+            .await;
+
+        // Ensure std directory exists and has files
+        if !std_dir.join("prelude.mlf").exists() {
+            self.client
+                .log_message(MessageType::INFO, "Std library not found in ~/.mlf/lexicons/mlf/, extracting embedded files...")
+                .await;
+
+            // Create directory
+            if let Err(e) = std::fs::create_dir_all(&std_dir) {
+                self.client
+                    .log_message(MessageType::ERROR, format!("Failed to create ~/.mlf/lexicons/mlf/: {}", e))
+                    .await;
+                return;
+            }
+
+            // Extract embedded files
+            self.extract_embedded_std_to_directory(&std_dir).await;
+        } else {
+            self.client
+                .log_message(MessageType::INFO, "Using existing std library from ~/.mlf/lexicons/mlf/")
+                .await;
+        }
+
+        // Load std files from ~/.mlf/lexicons/mlf/
+        self.load_std_from_directory(&std_dir).await;
+
+        self.client
+            .log_message(MessageType::INFO, "Finished loading std library documents")
+            .await;
+    }
+
+    /// Load fetched lexicons from project's .mlf cache directory
+    async fn load_project_lexicons(&self, workspace: &mut Workspace) -> std::result::Result<(), String> {
+        // Try to find project root by looking for mlf.toml
+        // We'll check a few common locations
+        let possible_roots = vec![
+            std::env::current_dir().ok(),
+            // Could add more heuristics here
+        ];
+
+        for maybe_root in possible_roots {
+            if let Some(root) = maybe_root {
+                if let Some(project_root) = find_mlf_project_root(&root) {
+                    let mlf_cache_dir = project_root.join(".mlf");
+                    let lexicons_dir = mlf_cache_dir.join("lexicons").join("mlf");
+
+                    if lexicons_dir.exists() {
+                        self.client
+                            .log_message(MessageType::INFO, format!("Loading project lexicons from {}", lexicons_dir.display()))
+                            .await;
+
+                        self.load_lexicons_from_directory(workspace, &lexicons_dir, &lexicons_dir).await?;
+
+                        self.client
+                            .log_message(MessageType::INFO, "Finished loading project lexicons")
+                            .await;
+
+                        return Ok(());
+                    }
+                }
             }
         }
+
+        Ok(())
+    }
+
+    /// Recursively load .mlf files from a directory into the workspace
+    async fn load_lexicons_from_directory(
+        &self,
+        workspace: &mut Workspace,
+        dir: &PathBuf,
+        base_dir: &PathBuf,
+    ) -> std::result::Result<(), String> {
+        if !dir.exists() {
+            return Ok(());
+        }
+
+        let entries = std::fs::read_dir(dir)
+            .map_err(|e| format!("Failed to read directory {}: {}", dir.display(), e))?;
+
+        for entry in entries.flatten() {
+            let path = entry.path();
+
+            if path.is_file() && path.extension().map_or(false, |e| e == "mlf") {
+                // Extract namespace from file path
+                if let Ok(rel_path) = path.strip_prefix(base_dir) {
+                    if let Some(path_str) = rel_path.to_str() {
+                        let namespace = path_str
+                            .strip_suffix(".mlf")
+                            .unwrap_or(path_str)
+                            .replace('/', ".")
+                            .replace('\\', ".");
+
+                        // Read and parse the file
+                        if let Ok(contents) = std::fs::read_to_string(&path) {
+                            if let Ok(lexicon) = mlf_lang::parser::parse_lexicon(&contents) {
+                                // Add to workspace (skip if already exists to avoid overwriting std)
+                                if let Err(e) = workspace.add_module(namespace.clone(), lexicon) {
+                                    self.client
+                                        .log_message(
+                                            MessageType::WARNING,
+                                            format!("Failed to add module {}: {:?}", namespace, e)
+                                        )
+                                        .await;
+                                }
+
+                                // Also add to documents for navigation
+                                if let Ok(uri) = Url::from_file_path(&path) {
+                                    self.documents.write().await.insert(
+                                        uri.clone(),
+                                        DocumentState {
+                                            text: contents.clone(),
+                                            lexicon: Some(mlf_lang::parser::parse_lexicon(&contents).unwrap()),
+                                            namespace: Some(namespace.clone()),
+                                        },
+                                    );
+
+                                    self.client
+                                        .log_message(
+                                            MessageType::INFO,
+                                            format!("Loaded project lexicon: {} (namespace: {})", uri, namespace)
+                                        )
+                                        .await;
+                                }
+                            }
+                        }
+                    }
+                }
+            } else if path.is_dir() {
+                // Recurse into subdirectory
+                Box::pin(self.load_lexicons_from_directory(workspace, &path, base_dir)).await?;
+            }
+        }
+
+        Ok(())
+    }
+
+    async fn load_std_from_directory(&self, std_dir: &PathBuf) {
+        // Read real files from directory
+        fn load_dir_recursive<'a>(
+            server: &'a MlfLanguageServer,
+            dir: &'a PathBuf,
+            base_dir: &'a PathBuf,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send + 'a>> {
+            Box::pin(async move {
+                if let Ok(entries) = std::fs::read_dir(dir) {
+                    for entry in entries.flatten() {
+                        let path = entry.path();
+                        if path.is_file() && path.extension().map_or(false, |e| e == "mlf") {
+                            if let Ok(contents) = std::fs::read_to_string(&path) {
+                                if let Ok(lexicon) = mlf_lang::parser::parse_lexicon(&contents) {
+                                    if let Ok(uri) = Url::from_file_path(&path) {
+                                        // Extract relative path for namespace
+                                        if let Ok(rel_path) = path.strip_prefix(base_dir) {
+                                            if let Some(path_str) = rel_path.to_str() {
+                                                let namespace = path_str
+                                                    .strip_suffix(".mlf")
+                                                    .unwrap_or(path_str)
+                                                    .replace('/', ".")
+                                                    .replace('\\', ".");
+
+                                                server.client
+                                                    .log_message(
+                                                        MessageType::INFO,
+                                                        format!("Loaded std document: {} (namespace: {})", uri, namespace)
+                                                    )
+                                                    .await;
+
+                                                server.documents.write().await.insert(
+                                                    uri,
+                                                    DocumentState {
+                                                        text: contents,
+                                                        lexicon: Some(lexicon),
+                                                        namespace: Some(namespace),
+                                                    },
+                                                );
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        } else if path.is_dir() {
+                            load_dir_recursive(server, &path, base_dir).await;
+                        }
+                    }
+                }
+            })
+        }
+
+        load_dir_recursive(self, std_dir, std_dir).await;
+    }
+
+    async fn extract_embedded_std_to_directory(&self, std_dir: &PathBuf) {
+        // Extract embedded files to ~/.mlf/std/
+        fn extract_embedded_dir<'a>(
+            server: &'a MlfLanguageServer,
+            dir: &'static include_dir::Dir<'static>,
+            base_std_dir: &'a PathBuf,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send + 'a>> {
+            Box::pin(async move {
+                for file in dir.files() {
+                    if let Some(path_str) = file.path().to_str() {
+                        if path_str.ends_with(".mlf") {
+                            if let Some(contents_str) = file.contents_utf8() {
+                                let file_path = base_std_dir.join(path_str);
+
+                                // Create parent directories
+                                if let Some(parent) = file_path.parent() {
+                                    let _ = std::fs::create_dir_all(parent);
+                                }
+
+                                // Write file
+                                if let Err(e) = std::fs::write(&file_path, contents_str) {
+                                    server.client
+                                        .log_message(
+                                            MessageType::ERROR,
+                                            format!("Failed to write std file {}: {}", file_path.display(), e)
+                                        )
+                                        .await;
+                                    continue;
+                                }
+
+                                server.client
+                                    .log_message(
+                                        MessageType::INFO,
+                                        format!("Extracted: {}", file_path.display())
+                                    )
+                                    .await;
+                            }
+                        }
+                    }
+                }
+
+                // Recursively process subdirectories
+                for subdir in dir.dirs() {
+                    extract_embedded_dir(server, subdir, base_std_dir).await;
+                }
+            })
+        }
+
+        extract_embedded_dir(self, &mlf_lang::STD_DIR, std_dir).await;
+    }
+
+    async fn load_prelude_document(&self) {
+        // Prelude is already included in STD_DIR, so this is handled by load_std_documents
+        // This function kept for backward compatibility but does nothing
     }
 
     async fn find_definition_in_workspace(
···
         current_namespace: &str,
         path: &Path,
     ) -> Option<(Url, mlf_lang::span::Span)> {
+        self.client
+            .log_message(
+                MessageType::INFO,
+                format!("find_definition_in_workspace: target_name={}, current_namespace={}, path={}",
+                    target_name, current_namespace, path.to_string())
+            )
+            .await;
+
         let workspace_guard = self.workspace.read().await;
         let workspace = workspace_guard.as_ref()?;
 
         // Resolve the reference to find which namespace it's in
         let target_namespace = workspace.resolve_reference_namespace(path, current_namespace)?;
 
+        self.client
+            .log_message(
+                MessageType::INFO,
+                format!("Resolved target namespace: {}", target_namespace)
+            )
+            .await;
+
         // Find the document with that namespace
         let documents = self.documents.read().await;
+
+        self.client
+            .log_message(
+                MessageType::INFO,
+                format!("Searching {} documents for namespace '{}'", documents.len(), target_namespace)
+            )
+            .await;
+
         for (doc_uri, doc_state) in documents.iter() {
             if let Some(doc_ns) = &doc_state.namespace {
+                self.client
+                    .log_message(
+                        MessageType::INFO,
+                        format!("Checking document {} with namespace '{}'", doc_uri, doc_ns)
+                    )
+                    .await;
+
                 if doc_ns == &target_namespace {
+                    self.client
+                        .log_message(
+                            MessageType::INFO,
+                            format!("Found matching namespace! Searching for item '{}'", target_name)
+                        )
+                        .await;
+
                     if let Some(lexicon) = &doc_state.lexicon {
                         // Find the item in this lexicon
                         for item in &lexicon.items {
-                            if get_item_name(item) == target_name {
+                            let item_name = get_item_name(item);
+                            if item_name == target_name {
                                 let def_span = match item {
                                     Item::Record(r) => r.name.span,
                                     Item::InlineType(i) => i.name.span,
···
                                     Item::Subscription(s) => s.name.span,
                                     Item::Use(_) => continue,
                                 };
+
+                                self.client
+                                    .log_message(
+                                        MessageType::INFO,
+                                        format!("Found definition of '{}' in {}", target_name, doc_uri)
+                                    )
+                                    .await;
 
                                 return Some((doc_uri.clone(), def_span));
                             }
···
             }
         }
 
+        self.client
+            .log_message(
+                MessageType::INFO,
+                format!("Definition not found for '{}'", target_name)
+            )
+            .await;
+
+        None
+    }
+
+    /// Find the definition for a use statement
+    /// For "use a.b.c", navigate to the definition of c in namespace a.b
+    /// For "use a.b", navigate to the first definition in namespace a.b
+    async fn find_definition_in_workspace_for_use(
+        &self,
+        use_stmt: &Use,
+        _current_namespace: &str,
+    ) -> Option<(Url, mlf_lang::span::Span)> {
+        // For "use a.b.c" or "use a.b.c { ... }", we want to navigate to the namespace a.b
+        // and find the type c (or the first type if it's just "use a.b")
+
+        let path = &use_stmt.path;
+
+        // Check if this looks like "use namespace.typename" (old syntax)
+        // or "use namespace" (new syntax)
+        let (target_namespace, target_type) = if let UseImports::Items(items) = &use_stmt.imports {
+            if items.len() == 1 && path.segments.len() >= 2
+                && items[0].name.name == path.segments.last().unwrap().name {
+                // Old syntax: use a.b.c as Foo
+                // Navigate to type "c" in namespace "a.b"
+                let ns = path.segments[..path.segments.len() - 1]
+                    .iter()
+                    .map(|s| s.name.as_str())
+                    .collect::<Vec<_>>()
+                    .join(".");
+                let type_name = path.segments.last().unwrap().name.clone();
+                (ns, Some(type_name))
+            } else {
+                // New syntax: use a.b { c, d }
+                // Navigate to namespace a.b
+                (path.to_string(), None)
+            }
+        } else {
+            // use a.b; or use a.b.*;
+            (path.to_string(), None)
+        };
+
+        self.find_definition_in_namespace(&target_namespace, target_type.as_deref().unwrap_or("")).await
+    }
+
+    /// Find a definition in a specific namespace
+    async fn find_definition_in_namespace(
+        &self,
+        target_namespace: &str,
+        target_name: &str,
+    ) -> Option<(Url, mlf_lang::span::Span)> {
+        let documents = self.documents.read().await;
+
+        self.client
+            .log_message(
+                MessageType::INFO,
+                format!("find_definition_in_namespace: namespace='{}', name='{}'", target_namespace, target_name)
+            )
+            .await;
+
+        for (doc_uri, doc_state) in documents.iter() {
+            if let Some(doc_ns) = &doc_state.namespace {
+                if doc_ns == target_namespace {
+                    if let Some(lexicon) = &doc_state.lexicon {
+                        // If target_name is empty, return the first definition
+                        if target_name.is_empty() {
+                            for item in &lexicon.items {
+                                let def_span = match item {
+                                    Item::Record(r) => Some(r.name.span),
+                                    Item::InlineType(i) => Some(i.name.span),
+                                    Item::DefType(d) => Some(d.name.span),
+                                    Item::Token(t) => Some(t.name.span),
+                                    Item::Query(q) => Some(q.name.span),
+                                    Item::Procedure(p) => Some(p.name.span),
+                                    Item::Subscription(s) => Some(s.name.span),
+                                    Item::Use(_) => None,
+                                };
+
+                                if let Some(span) = def_span {
+                                    return Some((doc_uri.clone(), span));
+                                }
+                            }
+                        } else {
+                            // Find specific item by name
+                            for item in &lexicon.items {
+                                let item_name = get_item_name(item);
+                                if item_name == target_name {
+                                    let def_span = match item {
+                                        Item::Record(r) => r.name.span,
+                                        Item::InlineType(i) => i.name.span,
+                                        Item::DefType(d) => d.name.span,
+                                        Item::Token(t) => t.name.span,
+                                        Item::Query(q) => q.name.span,
+                                        Item::Procedure(p) => p.name.span,
+                                        Item::Subscription(s) => s.name.span,
+                                        Item::Use(_) => continue,
+                                    };
+
+                                    return Some((doc_uri.clone(), def_span));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
         None
     }
 }
···
     Some(components.join("."))
 }
 
+/// Check if a URI points to a std library file that shouldn't be edited
+fn is_std_library_file(uri: &Url) -> bool {
+    if let Ok(path) = uri.to_file_path() {
+        // Check if the path contains ~/.mlf/lexicons/mlf/
+        if let Some(home_dir) = dirs::home_dir() {
+            let std_dir = home_dir.join(".mlf").join("lexicons").join("mlf");
+            if let Ok(canonical_path) = path.canonicalize() {
+                if let Ok(canonical_std_dir) = std_dir.canonicalize() {
+                    return canonical_path.starts_with(canonical_std_dir);
+                }
+            }
+        }
+    }
+    false
+}
+
+/// Find the project root by looking for mlf.toml
+fn find_mlf_project_root(start_path: &std::path::Path) -> Option<PathBuf> {
+    let mut current = start_path;
+
+    loop {
+        if current.join("mlf.toml").exists() {
+            return Some(current.to_path_buf());
+        }
+
+        current = current.parent()?;
+
+        // Stop at filesystem root
+        if current.parent().is_none() {
+            break;
+        }
+    }
+
+    None
+}
+
 #[tower_lsp::async_trait]
 impl LanguageServer for MlfLanguageServer {
     async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
···
                 hover_provider: Some(HoverProviderCapability::Simple(true)),
                 completion_provider: Some(CompletionOptions {
                     resolve_provider: Some(false),
-                    trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
+                    trigger_characters: Some(vec![
+                        ".".to_string(),
+                        ":".to_string(),
+                        " ".to_string(),
+                    ]),
                     ..Default::default()
                 }),
                 definition_provider: Some(OneOf::Left(true)),
···
         self.client
             .log_message(MessageType::INFO, "MLF Language Server initialized")
             .await;
+
+        // Initialize workspace with std library immediately on startup
+        // This ensures completion works even if did_open hasn't been called yet (e.g., after lsp-restart)
+        let mut workspace_guard = self.workspace.write().await;
+        if workspace_guard.is_none() {
+            tracing::info!("Initializing workspace with std library on startup");
+            match Workspace::with_std() {
+                Ok(mut ws) => {
+                    // Populate document storage with std library files for navigation
+                    self.load_std_documents().await;
+
+                    // Load project lexicons from .mlf cache
+                    if let Err(e) = self.load_project_lexicons(&mut ws).await {
+                        tracing::warn!("Failed to load project lexicons: {}", e);
+                        self.client
+                            .log_message(MessageType::WARNING, format!("Failed to load project lexicons: {}", e))
+                            .await;
+                    }
+
+                    *workspace_guard = Some(ws);
+                    tracing::info!("Workspace initialized successfully");
+                }
+                Err(e) => {
+                    tracing::error!("Failed to initialize workspace: {:?}", e);
+                    // Fallback to prelude if std loading fails
+                    match Workspace::with_prelude() {
+                        Ok(ws) => {
+                            self.load_prelude_document().await;
+                            *workspace_guard = Some(ws);
+                            tracing::info!("Workspace initialized with prelude only");
+                        }
+                        Err(_) => {
+                            *workspace_guard = Some(Workspace::new());
+                            tracing::warn!("Workspace initialized empty (no std or prelude)");
+                        }
+                    }
+                }
+            }
+        }
     }
 
     async fn shutdown(&self) -> Result<()> {
···
     }
 
     async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
+        tracing::debug!("Completion request received");
+
         let uri = params.text_document_position.text_document.uri;
         let position = params.text_document_position.position;
 
         let documents = self.documents.read().await;
+        tracing::debug!("Got documents lock");
+
         if let Some(doc_state) = documents.get(&uri) {
             let mut completions = vec![];
 
-            // Always provide keywords
-            let keywords = vec![
-                ("record", CompletionItemKind::KEYWORD, "Define a record type"),
-                ("inline type", CompletionItemKind::KEYWORD, "Define an inline type"),
-                ("def type", CompletionItemKind::KEYWORD, "Define a def type"),
-                ("token", CompletionItemKind::KEYWORD, "Define a token"),
-                ("query", CompletionItemKind::KEYWORD, "Define a query"),
-                ("procedure", CompletionItemKind::KEYWORD, "Define a procedure"),
-                ("subscription", CompletionItemKind::KEYWORD, "Define a subscription"),
-                ("use", CompletionItemKind::KEYWORD, "Import types from another module"),
-                ("constrained", CompletionItemKind::KEYWORD, "Add constraints to a type"),
-            ];
+            // Detect context
+            let text_before_cursor = if let Some(offset) = position_to_offset(&doc_state.text, position) {
+                &doc_state.text[..offset]
+            } else {
+                ""
+            };
 
-            for (label, kind, detail) in keywords {
-                completions.push(CompletionItem {
-                    label: label.to_string(),
-                    kind: Some(kind),
-                    detail: Some(detail.to_string()),
-                    ..Default::default()
-                });
-            }
+            let context = detect_context(text_before_cursor);
+            tracing::debug!("Context detected: {:?}", context);
 
-            // Primitive types
-            let primitives = vec![
-                "null", "boolean", "integer", "string", "bytes", "blob",
-            ];
+            match context {
+                MlfCompletionContext::UseStatement => {
+                    tracing::debug!("UseStatement completion");
 
-            for prim in primitives {
-                completions.push(CompletionItem {
-                    label: prim.to_string(),
-                    kind: Some(CompletionItemKind::TYPE_PARAMETER),
-                    detail: Some("Primitive type".to_string()),
-                    ..Default::default()
-                });
-            }
+                    // Extract the partial path already typed (e.g., "use com.atproto." -> "com.atproto")
+                    let last_line = text_before_cursor.lines().last().unwrap_or("");
+                    let after_use = last_line
+                        .trim_start()
+                        .strip_prefix("use ")
+                        .unwrap_or("")
+                        .trim_end();
+
+                    // Track if there's a trailing dot
+                    let has_trailing_dot = after_use.ends_with('.');
+                    let partial_path = after_use.trim_end_matches('.'); // Remove trailing dot for matching
+
+                    tracing::debug!("Partial path: '{}', has_trailing_dot: {}", partial_path, has_trailing_dot);
 
-            // If we have a parsed lexicon, provide type completions from current file
-            if let Some(lexicon) = &doc_state.lexicon {
-                for item in &lexicon.items {
-                    let (name, kind, detail) = match item {
-                        Item::Record(r) => (r.name.name.as_str(), CompletionItemKind::CLASS, "record"),
-                        Item::InlineType(i) => (i.name.name.as_str(), CompletionItemKind::TYPE_PARAMETER, "inline type"),
-                        Item::DefType(d) => (d.name.name.as_str(), CompletionItemKind::TYPE_PARAMETER, "def type"),
-                        Item::Token(t) => (t.name.name.as_str(), CompletionItemKind::ENUM, "token"),
-                        Item::Query(q) => (q.name.name.as_str(), CompletionItemKind::FUNCTION, "query"),
-                        Item::Procedure(p) => (p.name.name.as_str(), CompletionItemKind::FUNCTION, "procedure"),
-                        Item::Subscription(s) => (s.name.name.as_str(), CompletionItemKind::EVENT, "subscription"),
-                        Item::Use(_) => continue,
-                    };
+                    // Calculate the range to replace
+                    let use_start_offset = text_before_cursor.rfind("use ").map(|i| i + 4).unwrap_or(0);
+                    let use_start_pos = offset_to_position(&doc_state.text, use_start_offset);
 
-                    completions.push(CompletionItem {
-                        label: name.to_string(),
-                        kind: Some(kind),
-                        detail: Some(detail.to_string()),
-                        ..Default::default()
-                    });
+                    // Use shared namespace completion logic
+                    let workspace_guard = self.workspace.read().await;
+                    if let Some(workspace) = workspace_guard.as_ref() {
+                        completions.extend(namespace_completion::complete_namespace_path(
+                            workspace,
+                            &documents,
+                            doc_state.namespace.as_ref(),
+                            partial_path,
+                            has_trailing_dot,
+                            use_start_pos,
+                            position,
+                            &doc_state.text,
+                            true, // Suggest { }, *, and types after trailing dot in use statements
+                        ));
+                    }
                 }
-            }
 
-            // Check if we're at a field position to provide constraint completions
-            if let Some(offset) = position_to_offset(&doc_state.text, position) {
-                // Check if "constrained {" appears before cursor
-                if doc_state.text[..offset].ends_with("constrained {")
-                    || doc_state.text[..offset].contains("constrained {") {
+                MlfCompletionContext::ConstraintBlock => {
+                    // Only suggest constraint names
                     let constraint_items = vec![
                         ("maxLength", "Maximum string/array length"),
                         ("minLength", "Minimum string/array length"),
···
                         });
                     }
                 }
+
+                MlfCompletionContext::TypePosition => {
+                    // Extract text after the last ':' to detect if user is typing a namespace path
+                    let last_line = text_before_cursor.lines().last().unwrap_or("");
+                    let after_colon = last_line.rfind(':')
+                        .map(|idx| &last_line[idx + 1..])
+                        .unwrap_or("");
+
+                    // Trim only for detection purposes, but preserve space in offset calculation
+                    let after_colon_trimmed = after_colon.trim_start();
+
+                    // Check if user is typing a path (contains a dot)
+                    let is_typing_path = after_colon_trimmed.contains('.');
+
+                    tracing::debug!("Type position: after_colon_trimmed='{}', is_typing_path={}", after_colon_trimmed, is_typing_path);
+
+                    if is_typing_path {
+                        // User is typing a namespace path like "com.atproto."
+                        // Only suggest namespace path completions
+                        let has_trailing_dot = after_colon_trimmed.ends_with('.');
+                        let partial_path = after_colon_trimmed.trim_end_matches('.');
+
+                        tracing::debug!("Namespace path mode: partial_path='{}', has_trailing_dot={}", partial_path, has_trailing_dot);
+
+                        // Calculate the range to replace (from after ':' and any spaces to cursor)
+                        let colon_offset = text_before_cursor.rfind(':').map(|i| i + 1).unwrap_or(0);
+                        // Skip leading spaces to get to where the actual path starts
+                        let space_count = after_colon.len() - after_colon_trimmed.len();
+                        let replace_start_pos = offset_to_position(&doc_state.text, colon_offset + space_count);
+
+                        let workspace_guard = self.workspace.read().await;
+                        if let Some(workspace) = workspace_guard.as_ref() {
+                            completions.extend(namespace_completion::complete_namespace_path(
+                                workspace,
+                                &documents,
+                                doc_state.namespace.as_ref(),
+                                partial_path,
+                                has_trailing_dot,
+                                replace_start_pos,
+                                position,
+                                &doc_state.text,
+                                false, // Don't suggest { } or * in type positions
+                            ));
+                        }
+                    } else {
+                        // Not typing a path - suggest local types, primitives, imports, prelude
+                        tracing::debug!("Local type mode");
+
+                        // Primitive types
+                        let primitives = vec![
+                            "null", "boolean", "integer", "string", "bytes", "blob",
+                        ];
+
+                        for prim in primitives {
+                            completions.push(CompletionItem {
+                                label: prim.to_string(),
+                                kind: Some(CompletionItemKind::TYPE_PARAMETER),
+                                detail: Some("Primitive type".to_string()),
+                                ..Default::default()
+                            });
+                        }
+
+                        // Add defined types (records, inline types, def types, tokens only)
+                        if let Some(lexicon) = &doc_state.lexicon {
+                            for item in &lexicon.items {
+                                match item {
+                                    Item::Record(r) => {
+                                        completions.push(CompletionItem {
+                                            label: r.name.name.clone(),
+                                            kind: Some(CompletionItemKind::CLASS),
+                                            detail: Some("record".to_string()),
+                                            ..Default::default()
+                                        });
+                                    }
+                                    Item::InlineType(i) => {
+                                        completions.push(CompletionItem {
+                                            label: i.name.name.clone(),
+                                            kind: Some(CompletionItemKind::TYPE_PARAMETER),
+                                            detail: Some("inline type".to_string()),
+                                            ..Default::default()
+                                        });
+                                    }
+                                    Item::DefType(d) => {
+                                        completions.push(CompletionItem {
+                                            label: d.name.name.clone(),
+                                            kind: Some(CompletionItemKind::TYPE_PARAMETER),
+                                            detail: Some("def type".to_string()),
+                                            ..Default::default()
+                                        });
+                                    }
+                                    Item::Token(t) => {
+                                        completions.push(CompletionItem {
+                                            label: t.name.name.clone(),
+                                            kind: Some(CompletionItemKind::ENUM),
+                                            detail: Some("token".to_string()),
+                                            ..Default::default()
+                                        });
+                                    }
+                                    // Don't suggest queries, procedures, subscriptions as types
+                                    _ => {}
+                                }
+                            }
+                        }
+
+                        // Add imported types
+                        if let Some(current_namespace) = &doc_state.namespace {
+                            let workspace_guard = self.workspace.read().await;
+                            if let Some(workspace) = workspace_guard.as_ref() {
+                                let imports = workspace.get_imports(current_namespace);
+                                tracing::debug!("Found {} imports for namespace '{}'", imports.len(), current_namespace);
+
+                                for (local_name, original_path) in imports {
+                                    // Format the original path for display
+                                    let path_str = original_path.join(".");
+                                    tracing::debug!("  - {} from {}", local_name, path_str);
+                                    completions.push(CompletionItem {
+                                        label: local_name.clone(),
+                                        kind: Some(CompletionItemKind::TYPE_PARAMETER),
+                                        detail: Some(format!("imported from {}", path_str)),
+                                        ..Default::default()
+                                    });
+                                }
+
+                                // Add prelude types
+                                let prelude_types = workspace.get_namespace_types("prelude");
+                                tracing::debug!("Found {} prelude types", prelude_types.len());
+                                for type_name in prelude_types {
+                                    completions.push(CompletionItem {
+                                        label: type_name.clone(),
+                                        kind: Some(CompletionItemKind::TYPE_PARAMETER),
+                                        detail: Some("from prelude".to_string()),
+                                        ..Default::default()
+                                    });
+                                }
+
+                                // Add NSIDs (fully qualified type references)
+                                // This allows users to type full NSIDs like "com.atproto.repo.strongRef"
+                                let nsids = workspace.get_all_nsids();
+                                tracing::debug!("Found {} NSIDs", nsids.len());
+                                for (nsid, namespace, type_name) in nsids {
+                                    completions.push(CompletionItem {
+                                        label: nsid.clone(),
+                                        kind: Some(CompletionItemKind::REFERENCE),
+                                        detail: Some(format!("{} from {}", type_name, namespace)),
+                                        filter_text: Some(nsid.clone()),
+                                        sort_text: Some(format!("z{}", nsid)), // Sort NSIDs after local types
+                                        ..Default::default()
+                                    });
+                                }
+                            }
+                        }
+                    }
+
+                    tracing::debug!("Total completions: {}", completions.len());
+                }
+
+                MlfCompletionContext::TopLevel => {
+                    // Suggest keywords for top-level declarations
+                    let keywords = vec![
+                        ("record", CompletionItemKind::KEYWORD, "Define a record type"),
+                        ("inline type", CompletionItemKind::KEYWORD, "Define an inline type"),
+                        ("def type", CompletionItemKind::KEYWORD, "Define a def type"),
+                        ("token", CompletionItemKind::KEYWORD, "Define a token"),
+                        ("query", CompletionItemKind::KEYWORD, "Define a query"),
+                        ("procedure", CompletionItemKind::KEYWORD, "Define a procedure"),
+                        ("subscription", CompletionItemKind::KEYWORD, "Define a subscription"),
+                        ("use", CompletionItemKind::KEYWORD, "Import types from another module"),
+                    ];
+
+                    for (label, kind, detail) in keywords {
+                        completions.push(CompletionItem {
+                            label: label.to_string(),
+                            kind: Some(kind),
+                            detail: Some(detail.to_string()),
+                            ..Default::default()
+                        });
+                    }
+                }
+
+                MlfCompletionContext::Unknown => {
+                    // Unknown context - don't suggest anything to avoid incorrect completions
+                    // For example, when user is typing a field name but hasn't typed ':' yet
+                    tracing::debug!("Unknown context - no completions");
+                }
             }
 
             return Ok(Some(CompletionResponse::Array(completions)));
···
 
         if let Some(lexicon) = lexicon {
             if let Some(offset) = position_to_offset(&text, position) {
+                // Check if cursor is on a use statement
+                for item in &lexicon.items {
+                    if let Item::Use(use_stmt) = item {
+                        // Check if the cursor is within the use statement's path
+                        if use_stmt.path.span.start <= offset && offset <= use_stmt.path.span.end {
+                            self.client
+                                .log_message(
+                                    MessageType::INFO,
+                                    format!("Found use statement at cursor: {}", use_stmt.path.to_string())
+                                )
+                                .await;
+
+                            // Determine which type is being referenced
+                            // For "use a.b.c", we navigate to the definition of c in namespace a.b
+                            // For "use a.b { c }", we would navigate to c in namespace a.b
+
+                            // Handle go-to-definition for use statements
+                            if let Some(ref current_ns) = current_namespace {
+                                if let Some((def_uri, def_span)) =
+                                    self.find_definition_in_workspace_for_use(use_stmt, current_ns).await {
+
+                                    let documents = self.documents.read().await;
+                                    if let Some(target_doc) = documents.get(&def_uri) {
+                                        let range = span_to_range(&target_doc.text, def_span);
+
+                                        self.client
+                                            .log_message(
+                                                MessageType::INFO,
+                                                format!("Returning use statement definition from: {}", def_uri)
+                                            )
+                                            .await;
+
+                                        return Ok(Some(GotoDefinitionResponse::Scalar(
+                                            Location {
+                                                uri: def_uri,
+                                                range,
+                                            },
+                                        )));
+                                    }
+                                }
+                            }
+                        }
+
+                        // Check if cursor is on an imported item name
+                        if let UseImports::Items(items) = &use_stmt.imports {
+                            for import_item in items {
+                                if import_item.name.span.start <= offset && offset <= import_item.name.span.end {
+                                    self.client
+                                        .log_message(
+                                            MessageType::INFO,
+                                            format!("Found use item at cursor: {}", import_item.name.name)
+                                        )
+                                        .await;
+
+                                    // Navigate to the definition of this specific item
+                                    if current_namespace.is_some() {
+                                        // Construct the full path to the item
+                                        let target_namespace = use_stmt.path.to_string();
+                                        let item_name = if import_item.name.name == "main" {
+                                            // Special case: "main" resolves to namespace suffix
+                                            target_namespace.split('.').last().unwrap_or(&import_item.name.name)
+                                        } else {
+                                            &import_item.name.name
+                                        };
+
+                                        if let Some((def_uri, def_span)) =
+                                            self.find_definition_in_namespace(&target_namespace, item_name).await {
+
+                                            let documents = self.documents.read().await;
+                                            if let Some(target_doc) = documents.get(&def_uri) {
+                                                let range = span_to_range(&target_doc.text, def_span);
+
+                                                return Ok(Some(GotoDefinitionResponse::Scalar(
+                                                    Location {
+                                                        uri: def_uri,
+                                                        range,
+                                                    },
+                                                )));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
                 // Find type reference at this position
                 for item in &lexicon.items {
                     let type_to_check = match item {
···
 
                     if let Some(ty) = type_to_check {
                         if let Some(Type::Reference { path, .. }) = find_type_at_offset(ty, offset) {
+                            self.client
+                                .log_message(
+                                    MessageType::INFO,
+                                    format!("Found reference at cursor: {}", path.to_string())
+                                )
+                                .await;
+
                             // Find the definition of this type
                             let target_name = if path.segments.len() == 1 {
                                 &path.segments[0].name
···
                                 &path.segments.last().unwrap().name
                             };
 
+                            self.client
+                                .log_message(
+                                    MessageType::INFO,
+                                    format!("Target name: {}, path segments: {}", target_name, path.segments.len())
+                                )
+                                .await;
+
                             // First try to find in current file
                             for target_item in &lexicon.items {
                                 if get_item_name(target_item) == target_name {
···
 
                                     let range = span_to_range(&text, def_span);
 
+                                    self.client
+                                        .log_message(
+                                            MessageType::INFO,
+                                            format!("Found definition in current file")
+                                        )
+                                        .await;
+
                                     return Ok(Some(GotoDefinitionResponse::Scalar(
                                         Location {
                                             uri: uri.clone(),
···
                                 }
                             }
 
+                            self.client
+                                .log_message(
+                                    MessageType::INFO,
+                                    format!("Not found in current file, searching workspace...")
+                                )
+                                .await;
+
                             // Not found in current file - try workspace
                             if let Some(ref current_ns) = current_namespace {
+                                self.client
+                                    .log_message(
+                                        MessageType::INFO,
+                                        format!("Current namespace: {}", current_ns)
+                                    )
+                                    .await;
+
                                 if let Some((def_uri, def_span)) =
                                     self.find_definition_in_workspace(target_name, current_ns, path).await {
 
···
                                     if let Some(target_doc) = documents.get(&def_uri) {
                                         let range = span_to_range(&target_doc.text, def_span);
 
+                                        self.client
+                                            .log_message(
+                                                MessageType::INFO,
+                                                format!("Returning definition from workspace: {}", def_uri)
+                                            )
+                                            .await;
+
                                         return Ok(Some(GotoDefinitionResponse::Scalar(
                                             Location {
                                                 uri: def_uri,
···
                                         )));
                                     }
                                 }
+                            } else {
+                                self.client
+                                    .log_message(
+                                        MessageType::WARNING,
+                                        format!("No current namespace available")
+                                    )
+                                    .await;
                             }
                         }
                     }

std/com/atproto/admin/defs.mlf

···
     did!: Did,
     handle!: Handle,
     email: string,
-    relatedRecords: [unknown],
+    relatedRecords: unknown[],
     indexedAt!: Datetime,
     invitedBy: com.atproto.server.defs.inviteCode,
-    invites: [com.atproto.server.defs.inviteCode],
+    invites: com.atproto.server.defs.inviteCode[],
     invitesDisabled: boolean,
     emailConfirmedAt: Datetime,
     inviteNote: string,
     deactivatedAt: Datetime,
-    threatSignatures: [threatSignature],
+    threatSignatures: threatSignature[],
 };
 
 def type repoRef = {

std/com/atproto/label/defs.mlf

···
 };
 
 def type selfLabels = {
-    values!: [selfLabel] constrained { maxLength: 10 },
+    values!: selfLabel[] constrained { maxLength: 10 },
 };
 
 def type selfLabel = {
···
     blurs!: string constrained { knownValues: ["content", "media", "none"] },
     defaultSetting: string constrained { knownValues: ["ignore", "warn", "hide"], default: "warn" },
     adultOnly: boolean,
-    locales!: [labelValueDefinitionStrings],
+    locales!: labelValueDefinitionStrings[],
 };
 
 def type labelValueDefinitionStrings = {

std/com/atproto/server/defs.mlf

···
     forAccount!: string,
     createdBy!: string,
     createdAt!: Datetime,
-    uses!: [inviteCodeUse],
+    uses!: inviteCodeUse[],
 };
 
 def type inviteCodeUse = {