feat(Mountain): Wire tree-view children to extension host and add diagnostic tags

Implement the full round-trip for tree-view data providers:
1. Add `tree:getChildren` invoke handler in WindServiceHandlers - allows Wind/Sky UI to request tree children directly without waiting for Cocoon to ask first
2. Wire GetTreeChildren gRPC in TreeView.rs to forward requests to the `$provideTreeChildren` handler in Cocoon, returning actual TreeItem data instead of empty stub
3. Add viewId→handle hashing to match RegisterTreeViewProvider's provider lookup

Also add two new diagnostic tags per the Batch 3 logging spec in DevLog.rs:
- `scheme-assets`: logs vscode-file:// request routing, MIME type, byte size
- `ext-scan`: logs extension scanner accept/skip decisions with is_builtin flag and skip reasons

These tags catch the subsystems new traffic passes through so regressions surface as silent tag counts going to zero. Extension tree views (GitLens, SCM, debug, tasks) now render with data from providers instead of appearing empty.

Author: NikolaRHristov

Source/Binary/Build/Scheme.rs

@@ -740,6 +740,7 @@ pub fn VscodeFileSchemeHandler<R:tauri::Runtime>(
 ) -> Response<Vec<u8>> {
 	let Uri = Request.uri().to_string();
 	dev_log!("lifecycle", "[LandFix:VscodeFile] Request: {}", Uri);
+	dev_log!("scheme-assets", "[SchemeAssets] request uri={}", Uri);
 
 	// Extract path from: vscode-file://vscode-app/path/to/file
 	// The authority is "vscode-app", the path starts after it
@@ -869,6 +870,13 @@ pub fn VscodeFileSchemeHandler<R:tauri::Runtime>(
 			Mime,
 			Asset.bytes.len()
 		);
+		dev_log!(
+			"scheme-assets",
+			"[SchemeAssets] serve source=embedded path={} mime={} bytes={}",
+			CleanPath,
+			Mime,
+			Asset.bytes.len()
+		);
 
 		return Builder::new()
 			.status(200)

Source/ExtensionManagement/Scanner.rs

@@ -368,6 +368,19 @@ pub async fn ScanDirectoryForExtensions(
 							// extensions only.
 							Description.IsBuiltin = !IsUserPath;
 
+							dev_log!(
+								"ext-scan",
+								"[ExtScan] accept path={} is_user={} is_builtin={} id={}",
+								PotentialExtensionPath.display(),
+								IsUserPath,
+								Description.IsBuiltin,
+								Description
+									.Identifier
+									.get("value")
+									.and_then(|V| V.as_str())
+									.unwrap_or("<unknown>")
+							);
+
 							FoundExtensions.push(Description);
 						},
 
@@ -379,6 +392,12 @@ pub async fn ScanDirectoryForExtensions(
 								PotentialExtensionPath.display(),
 								error
 							);
+							dev_log!(
+								"ext-scan",
+								"[ExtScan] skip path={} reason=parse-failure err={}",
+								PotentialExtensionPath.display(),
+								error
+							);
 						},
 					}
 				},
@@ -390,6 +409,12 @@ pub async fn ScanDirectoryForExtensions(
 						PackageJsonPath.display(),
 						error
 					);
+					dev_log!(
+						"ext-scan",
+						"[ExtScan] skip path={} reason=no-package-json err={}",
+						PotentialExtensionPath.display(),
+						error
+					);
 				},
 			}
 		}

Source/IPC/DevLog.rs

@@ -98,6 +98,22 @@
 //! | `ext-activate`   | Per-extension activate: start, outcome (ok/fail/skip), duration        |
 //! | `breaker`        | Cocoon `MountainClientService` circuit-breaker state transitions        |
 //! | `cel-dispatch`   | SkyBridge `cel:*` CustomEvent dispatch + consumer-present flag         |
+//!
+//! ### Batch 3 diagnostic tags
+//!
+//! Added 2026-04-23 late after Batches 3-6 wired notification handlers,
+//! git channel, tree-view dataProvider forwarding, and medium stub
+//! backfill. These tags catch the subsystems the new traffic passes
+//! through so regressions surface as silent tag counts going to zero
+//! (or, for `tauri-invoke`, per-invoke latency spikes).
+//!
+//! | Tag                | Scope                                                                   |
+//! |--------------------|-------------------------------------------------------------------------|
+//! | `ext-scan`         | Extension scanner decisions: is-builtin vs user, skip reasons, counts   |
+//! | `scheme-assets`    | `vscode-file://` / `vscode-resource://` request routing, MIME, bytes    |
+//! | `preload-shim`     | Wind `Preload.ts` globals wiring, VS Code `ipcRenderer` polyfill install|
+//! | `tauri-invoke`     | Per-invoke method + duration (augments `ipc`'s paired invoke/done lines)|
+//! | `bootstrap-stage`  | Cocoon `Effect/Bootstrap.ts` stage timings (start/ok/fail per phase)    |
 
 use std::{
 	fs::{File, OpenOptions, create_dir_all},

Source/IPC/WindServiceHandlers/mod.rs

@@ -1698,6 +1698,60 @@ pub async fn mountain_ipc_invoke(app_handle:AppHandle, command:String, args:Vec<
 					Git::HandleIsAvailable(args).await
 				},
 
+				// Tree-view child lookup from the renderer side. Mirrors the
+				// Cocoon→Mountain `GetTreeChildren` gRPC path (see
+				// `RPC/CocoonService/TreeView.rs::GetTreeChildren`) but is
+				// invoked by the Wind/Sky tree-view bridge so the UI can
+				// request children directly without waiting for Cocoon to
+				// ask first. Payload: `[{ viewId, treeItemHandle? }]`.
+				"tree:getChildren" => {
+					let ViewId = args
+						.first()
+						.and_then(|V| V.get("viewId").or_else(|| V.get(0)))
+						.and_then(Value::as_str)
+						.unwrap_or("")
+						.to_string();
+					let ItemHandle = args
+						.first()
+						.and_then(|V| V.get("treeItemHandle").or_else(|| V.get(1)))
+						.and_then(Value::as_str)
+						.unwrap_or("")
+						.to_string();
+					dev_log!(
+						"tree-view",
+						"[TreeView] invoke:getChildren view={} parent={}",
+						ViewId,
+						ItemHandle
+					);
+					if ViewId.is_empty() {
+						Err("tree:getChildren requires viewId".to_string())
+					} else {
+						let Parameters = json!({
+							"viewId": ViewId,
+							"treeItemHandle": ItemHandle,
+						});
+						match crate::Vine::Client::SendRequest(
+							"cocoon-main",
+							"$provideTreeChildren".to_string(),
+							Parameters,
+							5000,
+						)
+						.await
+						{
+							Ok(Value_) => Ok(Value_),
+							Err(Error) => {
+								dev_log!(
+									"tree-view",
+									"[TreeView] invoke:getChildren error view={} err={:?}",
+									ViewId,
+									Error
+								);
+								Ok(json!({ "items": [] }))
+							},
+						}
+					}
+				},
+
 				// Atom L2: unknown-command fallback consults the Channel registry so
 				// the log distinguishes three states:
 				//   1. typo / never-registered wire string (registry::from_str Err)

Source/RPC/CocoonService/TreeView.rs

@@ -3,18 +3,29 @@
 //!
 //! Typed gRPC RPCs: register_tree_view_provider, get_tree_children.
 
-use serde_json::json;
+use serde_json::{Value, json};
 use tauri::Emitter;
 use tonic::{Response, Status};
 use CommonLibrary::{IPC::SkyEvent::SkyEvent, LanguageFeature::DTO::ProviderType::ProviderType};
 
 use super::CocoonServiceImpl;
 use crate::{
 	ApplicationState::DTO::ProviderRegistrationDTO::ProviderRegistrationDTO,
-	Vine::Generated::{Empty, GetTreeChildrenRequest, GetTreeChildrenResponse, RegisterTreeViewProviderRequest},
+	Vine::{
+		Client::SendRequest,
+		Generated::{Empty, GetTreeChildrenRequest, GetTreeChildrenResponse, RegisterTreeViewProviderRequest, TreeItem},
+	},
 	dev_log,
 };
 
+/// Matches the viewId-derived handle used by `RegisterTreeViewProvider`.
+fn ViewIdHandle(ViewId:&str) -> u32 {
+	ViewId
+		.as_bytes()
+		.iter()
+		.fold(0u32, |Acc, B| Acc.wrapping_mul(31).wrapping_add(*B as u32))
+}
+
 pub async fn RegisterTreeViewProvider(
 	Service:&CocoonServiceImpl,
 	req:RegisterTreeViewProviderRequest,
@@ -59,16 +70,82 @@ pub async fn GetTreeChildren(
 	req:GetTreeChildrenRequest,
 ) -> Result<Response<GetTreeChildrenResponse>, Status> {
 	dev_log!("cocoon", "[CocoonService] get_tree_children: view={}", req.view_id);
+
+	let Handle = ViewIdHandle(&req.view_id);
+	let Provider = Service
+		.environment
+		.ApplicationState
+		.Extension
+		.ProviderRegistration
+		.GetProvider(Handle);
+
+	if Provider.is_none() {
+		dev_log!(
+			"tree-view",
+			"[TreeView] get-children view={} parent_handle={} - no provider registered",
+			req.view_id,
+			req.tree_item_handle
+		);
+		return Ok(Response::new(GetTreeChildrenResponse { items:Vec::new() }));
+	}
+
 	dev_log!(
 		"tree-view",
-		"[TreeView] get-children view={} parent_handle={} - STUB returns empty (Mountain→Cocoon round-trip not wired)",
+		"[TreeView] get-children view={} parent_handle={} - forwarding to Cocoon $provideTreeChildren",
 		req.view_id,
 		req.tree_item_handle
 	);
 
-	// Tree children are fetched by forwarding to Cocoon via the generic RPC path.
-	// The extension registers a TreeDataProvider; when Sky needs children,
-	// Mountain looks up the provider handle and invokes Cocoon.
-	// For now return empty - will be wired when Cocoon activation is complete.
-	Ok(Response::new(GetTreeChildrenResponse { items:Vec::new() }))
+	// Round-trip to the Cocoon-side TreeDataProvider. The sidecar identifier
+	// mirrors the one `RegisterTreeViewProvider` stored. The handler key
+	// `$provideTreeChildren` is the VS Code ext-host shim name the shim layer
+	// dispatches on; see
+	// `Cocoon/Source/Service/ExtensionHostHandler/TreeView.ts` (added in the
+	// same batch).
+	let Parameters = json!({
+		"viewId": req.view_id,
+		"treeItemHandle": req.tree_item_handle,
+		"handle": Handle,
+	});
+
+	// 5s default - TreeDataProvider.getChildren can walk FS for folder views,
+	// but should never block a UI thread forever. Longer waits fall through
+	// to an empty result (consumer can re-request when the view is focused).
+	let Response_ = match SendRequest("cocoon-main", "$provideTreeChildren".to_string(), Parameters, 5000).await {
+		Ok(Value_) => Value_,
+		Err(Error) => {
+			dev_log!(
+				"tree-view",
+				"[TreeView] get-children view={} error forwarding to Cocoon: {:?}",
+				req.view_id,
+				Error
+			);
+			return Ok(Response::new(GetTreeChildrenResponse { items:Vec::new() }));
+		},
+	};
+
+	let Items = Response_
+		.get("items")
+		.and_then(Value::as_array)
+		.cloned()
+		.unwrap_or_default()
+		.into_iter()
+		.map(|Item| {
+			let Handle = Item.get("handle").and_then(Value::as_str).unwrap_or("").to_string();
+			let Label = Item.get("label").and_then(Value::as_str).unwrap_or("").to_string();
+			let IsCollapsed = Item.get("isCollapsed").and_then(Value::as_bool).unwrap_or(false);
+			let Icon = Item.get("icon").and_then(Value::as_str).unwrap_or("").to_string();
+			TreeItem { handle:Handle, label:Label, is_collapsed:IsCollapsed, icon:Icon }
+		})
+		.collect::<Vec<TreeItem>>();
+
+	dev_log!(
+		"tree-view",
+		"[TreeView] get-children view={} parent_handle={} children={}",
+		req.view_id,
+		req.tree_item_handle,
+		Items.len()
+	);
+
+	Ok(Response::new(GetTreeChildrenResponse { items:Items }))
 }