perf(lsp): cache ValidatorRegistry across validations (#182)

* perf(lsp): cache ValidatorRegistry across validations

Reuse the ValidatorRegistry instance in the LSP Backend struct instead
of creating a new registry for every validation call. The registry is
now wrapped in Arc and shared across all validation operations.

Changes:
- Add `registry: Arc<agnix_core::ValidatorRegistry>` field to Backend
- Initialize registry once in Backend::new() with with_defaults()
- Use validate_file_with_registry() instead of validate_file()
- Update doc comments to reflect the optimization
- Add test_cached_registry_used_for_multiple_validations test

This eliminates redundant HashMap allocations and validator factory
lookups on each file validation, improving LSP server performance for
workspaces with many files.

Closes #171

* fix: clean up AI slop in test comments

* docs: clarify registry thread-safety and test purpose

- Add comment explaining Arc is for spawn_blocking task sharing
- Update test docstring to clarify it's a regression test for thread-safety

* docs: add CHANGELOG entry for ValidatorRegistry caching

Author: avifenesh

CHANGELOG.md

@@ -88,6 +88,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Comprehensive test coverage with 8 fixtures
 
 ### Performance
+- LSP server now caches ValidatorRegistry in Backend struct (#171)
+  - Registry wrapped in Arc and shared across spawn_blocking validation tasks
+  - Eliminates redundant HashMap allocations and validator factory lookups per validation
 - AS-015 directory size validation now short-circuits when limit exceeded, improving performance on large skill directories (#84)
 - Stream file walk to reduce memory usage on large repositories (#172)
   - Replaced collect-then-validate pattern with streaming par_bridge()

crates/agnix-lsp/src/backend.rs

@@ -47,11 +47,8 @@ fn create_error_diagnostic(code: &str, message: String) -> Diagnostic {
 ///
 /// # Performance Notes
 ///
-/// The `LintConfig` is cached and reused across validations to avoid
-/// repeated allocations. The `ValidatorRegistry` is currently created
-/// per-validation inside `agnix_core::validate_file` - this is a known
-/// limitation of the agnix-core API that could be optimized in the future
-/// by using `validate_file_with_registry` with a shared registry.
+/// Both `LintConfig` and `ValidatorRegistry` are cached and reused across
+/// validations to avoid repeated allocations.
 pub struct Backend {
     client: Client,
     /// Cached lint configuration reused across validations.
@@ -61,6 +58,9 @@ pub struct Backend {
     /// Set during initialize() from the client's root_uri.
     workspace_root: RwLock<Option<PathBuf>>,
     documents: RwLock<HashMap<Url, String>>,
+    /// Cached validator registry reused across validations.
+    /// Immutable after construction; Arc enables sharing across spawn_blocking tasks.
+    registry: Arc<agnix_core::ValidatorRegistry>,
 }
 
 impl Backend {
@@ -71,6 +71,7 @@ impl Backend {
             config: RwLock::new(Arc::new(agnix_core::LintConfig::default())),
             workspace_root: RwLock::new(None),
             documents: RwLock::new(HashMap::new()),
+            registry: Arc::new(agnix_core::ValidatorRegistry::with_defaults()),
         }
     }
 
@@ -79,12 +80,15 @@ impl Backend {
     /// agnix-core validation is CPU-bound and synchronous, so we run it
     /// in a blocking task to avoid blocking the async runtime.
     ///
-    /// The `LintConfig` is cloned from the cached instance to avoid
-    /// repeated allocations on each validation.
+    /// Both `LintConfig` and `ValidatorRegistry` are cloned from cached
+    /// instances to avoid repeated allocations on each validation.
     async fn validate_file(&self, path: PathBuf) -> Vec<Diagnostic> {
         let config = Arc::clone(&*self.config.read().await);
-        let result =
-            tokio::task::spawn_blocking(move || agnix_core::validate_file(&path, &config)).await;
+        let registry = Arc::clone(&self.registry);
+        let result = tokio::task::spawn_blocking(move || {
+            agnix_core::validate_file_with_registry(&path, &config, &registry)
+        })
+        .await;
 
         match result {
             Ok(Ok(diagnostics)) => to_lsp_diagnostics(diagnostics),
@@ -981,4 +985,61 @@ model: sonnet
 
         // All validations should complete (config is reused internally)
     }
+
+    /// Regression test: validates multiple files using the cached registry.
+    /// Verifies the Arc<ValidatorRegistry> is thread-safe across spawn_blocking tasks.
+    #[tokio::test]
+    async fn test_cached_registry_used_for_multiple_validations() {
+        let (service, _socket) = LspService::new(Backend::new);
+
+        // Initialize
+        service
+            .inner()
+            .initialize(InitializeParams::default())
+            .await
+            .unwrap();
+
+        let temp_dir = tempfile::tempdir().unwrap();
+
+        // Skill file
+        let skill_path = temp_dir.path().join("SKILL.md");
+        std::fs::write(
+            &skill_path,
+            r#"---
+name: test-skill
+version: 1.0.0
+model: sonnet
+---
+
+# Test Skill
+"#,
+        )
+        .unwrap();
+
+        // CLAUDE.md file
+        let claude_path = temp_dir.path().join("CLAUDE.md");
+        std::fs::write(
+            &claude_path,
+            r#"# Project Memory
+
+This is a test project.
+"#,
+        )
+        .unwrap();
+
+        for path in [&skill_path, &claude_path] {
+            let uri = Url::from_file_path(path).unwrap();
+            service
+                .inner()
+                .did_open(DidOpenTextDocumentParams {
+                    text_document: TextDocumentItem {
+                        uri,
+                        language_id: "markdown".to_string(),
+                        version: 1,
+                        text: String::new(),
+                    },
+                })
+                .await;
+        }
+    }
 }