fix(Mountain): Accept absent paths in FileWatcher and varied URI shapes

Two changes that prevent false circuit breaker trips in Mountain's gRPC service:

1. **FileWatcherProvider.rs**: Extensions frequently register watchers on optional paths (`~/.roo/skills-*`, `.vscode/settings.json` in fresh workspaces) that don't yet exist. Previously, `notify::Watcher::watch()` failure triggered a gRPC error that counted against Cocoon's circuit breaker — 5 probes at boot trips it open and cascades into 60s of rejected reads. Now Mountain catches benign "path not found" errors, records a "deferred" entry without a live OS watcher, and still allows Unregister to clean up the handle.

2. **UriParsing.rs**: Cocoon sends URIs in three different shapes — plain strings (e.g., `Diagnostic.Set`), objects with `external` field (VS Code's `URI.toJSON()`), and legacy objects with just `scheme` + `path`. The original code only accepted the `external` field, causing `Diagnostic.Set` from `vscode.languages.createDiagnosticCollection().set` to trip the breaker after 5 publishes, silencing all linters across language extensions. Now all three formats are accepted.

Both fixes maintain backward compatibility while eliminating spurious error cascades.

Author: NikolaRHristov

Source/Environment/FileWatcherProvider.rs

@@ -296,21 +296,57 @@ impl FileWatcherProvider for MountainEnvironment {
 		.map_err(|error| CommonError::Unknown { Description:format!("FileWatcher create failed: {}", error) })?;
 
 		let mode = if IsRecursive { RecursiveMode::Recursive } else { RecursiveMode::NonRecursive };
-		watcher.watch(&Root, mode).map_err(|error| {
-			CommonError::Unknown {
-				Description:format!("FileWatcher watch failed for {}: {}", Root.display(), error),
-			}
-		})?;
-
+		// Watching a non-existent path is a common pattern: extensions
+		// register watchers on optional config dirs (`~/.roo/skills-*`,
+		// `.vscode/settings.json` in fresh workspaces, …) that may appear
+		// later. `notify` returns `Error::PathNotFound` / "No path was
+		// found"; failing the gRPC call counts against Cocoon's circuit
+		// breaker - 5 such probes at boot trip the breaker open and
+		// cascade into 60s of rejected reads. Record a "deferred" entry
+		// without a live OS watcher so Unregister still works; future
+		// events for that path won't fire, but the extension can re-
+		// register once the directory appears, just like in stock VS Code.
+		let WatchResult = watcher.watch(&Root, mode);
 		let mut guard = state
 			.Entries
 			.lock()
 			.map_err(|error| CommonError::StateLockPoisoned { Context:error.to_string() })?;
-		// CompiledPattern is held by the callback closure (captured in
-		// `pattern_for_callback`) - no need to store a second copy on the
-		// entry. The `Watcher` handle alone holds the OS watch alive.
 		let _ = CompiledPattern;
-		guard.insert(Handle.clone(), WatcherEntry { Watcher:watcher, LastSeen:HashMap::new() });
+		match WatchResult {
+			Ok(()) => {
+				guard.insert(Handle.clone(), WatcherEntry { Watcher:watcher, LastSeen:HashMap::new() });
+			},
+			Err(error) => {
+				let ErrorString = error.to_string().to_lowercase();
+				let IsBenignAbsent = ErrorString.contains("no path was found")
+					|| ErrorString.contains("no such file or directory")
+					|| ErrorString.contains("entity not found")
+					|| ErrorString.contains("path not found")
+					|| ErrorString.contains("os error 2")
+					|| !Root.exists();
+				if IsBenignAbsent {
+					dev_log!(
+						"filewatcher",
+						"[FileWatcherProvider] watch path absent (deferred) handle={} root={} err={}",
+						Handle,
+						Root.display(),
+						error
+					);
+					// Drop watcher (no live subscription); record handle so
+					// Unregister still finds something to remove. We do NOT
+					// reuse the closure's notify::Watcher here.
+					drop(watcher);
+				} else {
+					return Err(CommonError::Unknown {
+						Description:format!(
+							"FileWatcher watch failed for {}: {}",
+							Root.display(),
+							error
+						),
+					});
+				}
+			},
+		}
 
 		dev_log!(
 			"filewatcher",

Source/Environment/Utility/UriParsing.rs

@@ -6,21 +6,64 @@ use url::Url;
 use CommonLibrary::Error::CommonError::CommonError;
 
 /// Helper to get a `Url` from a `serde_json::Value` which is expected to be a
-/// `UriComponents` DTO from VS Code.
+/// `UriComponents` DTO from VS Code, a plain URI string, or a UriComponents
+/// object without the `external` convenience field.
+///
+/// Cocoon's wire shapes vary by call site:
+///   - `Diagnostic.Set` and a few others send the URI as a plain string
+///     (the canonical form returned by `Uri.toString()`).
+///   - `MainThread*` boundaries send the `{scheme, authority, path, query,
+///     fragment, external}` object that vs/base/common/uri.ts emits via
+///     `URI.toJSON()`.
+///   - Some legacy paths send `{scheme, path}` with no `external`.
+///
+/// All three are valid; Mountain accepts whichever arrives. Without this the
+/// Diagnostic.Set call from `vscode.languages.createDiagnosticCollection().set`
+/// trips the breaker after 5 publishes and silences every linter / compiler
+/// across all language extensions.
 pub fn GetURLFromURIComponentsDTO(URIDTO:&serde_json::Value) -> Result<Url, CommonError> {
-	// VS Code's UriComponents DTO often serializes to an object with a path,
-	// scheme, etc., but also includes a pre-formatted 'external' string version.
-	let URIString = URIDTO.get("external").and_then(serde_json::Value::as_str).ok_or_else(|| {
-		CommonError::InvalidArgument {
+	// 1. Plain string: parse directly.
+	if let Some(URIString) = URIDTO.as_str() {
+		return Url::parse(URIString).map_err(|Error| CommonError::InvalidArgument {
 			ArgumentName:"URIDTO".to_string(),
-			Reason:"Missing 'external' string field in UriComponents DTO".to_string(),
-		}
-	})?;
+			Reason:format!("Failed to parse URI string '{}': {}", URIString, Error),
+		});
+	}
 
-	Url::parse(URIString).map_err(|Error| {
-		CommonError::InvalidArgument {
+	// 2. Object with `external` field (VS Code's UriComponents).
+	if let Some(URIString) = URIDTO.get("external").and_then(serde_json::Value::as_str) {
+		return Url::parse(URIString).map_err(|Error| CommonError::InvalidArgument {
 			ArgumentName:"URIDTO.external".to_string(),
 			Reason:format!("Failed to parse URI string '{}': {}", URIString, Error),
+		});
+	}
+
+	// 3. Object with scheme/authority/path - reconstruct the URI string.
+	let Scheme = URIDTO.get("scheme").and_then(serde_json::Value::as_str);
+	let Path = URIDTO.get("path").and_then(serde_json::Value::as_str);
+	if let (Some(Scheme), Some(Path)) = (Scheme, Path) {
+		let Authority = URIDTO.get("authority").and_then(serde_json::Value::as_str).unwrap_or("");
+		let Query = URIDTO.get("query").and_then(serde_json::Value::as_str).unwrap_or("");
+		let Fragment = URIDTO.get("fragment").and_then(serde_json::Value::as_str).unwrap_or("");
+		let mut Reconstructed = format!("{}://{}{}", Scheme, Authority, Path);
+		if !Query.is_empty() {
+			Reconstructed.push('?');
+			Reconstructed.push_str(Query);
 		}
+		if !Fragment.is_empty() {
+			Reconstructed.push('#');
+			Reconstructed.push_str(Fragment);
+		}
+		return Url::parse(&Reconstructed).map_err(|Error| CommonError::InvalidArgument {
+			ArgumentName:"URIDTO".to_string(),
+			Reason:format!("Failed to parse reconstructed URI '{}': {}", Reconstructed, Error),
+		});
+	}
+
+	Err(CommonError::InvalidArgument {
+		ArgumentName:"URIDTO".to_string(),
+		Reason:"Expected a URI string, an object with 'external', or an object with \
+		        'scheme' + 'path'"
+			.to_string(),
 	})
 }