feat(Mountain): Add RenderDevLog command and diagnostic logging tags

Add a new Tauri command `RenderDevLog` that bridges TypeScript-side tagged logs (Wind/Sky/Cocoon) into Mountain's `dev_log!` file sink. This enables a single `Mountain.dev.log` to carry the complete tag-filterable picture of a session, rather than requiring cross-referencing between browser console and log file.

Also add five new diagnostic tags to isolate architectural gaps during debugging:
- `notif-drop`: Notifications hitting the default arm (no handler)
- `provider-register`: Accepted register_*_provider notifications with extension IDs
- `channel-stub`: Wind/Output TauriMainProcessService.call stub hits vs route vs miss
- `git`: localGit channel, GitExec RPC, SCM provider group updates
- `tree-view`: tree.register, GetTreeChildren, sky://tree-view/create events

Apply tags across SCM.rs, TreeView.rs, CreateEffectForRequest/TreeView.rs, and MountainVinegRPCService.rs to provide visibility into extension host integration issues.

Impact: Developers can now filter `LAND_DEV_LOG=git,tree-view` to isolate specific subsystem issues, and TS-originated logs appear in the same file with `[RenderDevLog]` prefix for grep separation.

Author: NikolaRHristov

Source/Binary/IPC/RenderDevLogCommand.rs

@@ -0,0 +1,43 @@
+//! # RenderDevLogCommand
+//!
+//! Bridges TypeScript-side tagged logs (Wind / Sky / Cocoon running in the
+//! WebView) into Mountain's `dev_log!` file sink so a single
+//! `Mountain.dev.log` carries the complete tag-filterable picture of a
+//! session, not just the Rust portion.
+//!
+//! ## Why
+//!
+//! Wind's `Function/DevLog.ts` prints to `console.log`, visible only in
+//! DevTools. Mountain's `dev_log!` writes to a timestamped
+//! `Mountain.dev.log` with `LAND_DEV_LOG` tag filtering. The two observe
+//! the same boot but the outputs live in two places - reviewing a session
+//! means cross-referencing browser console + tail-f on the file. This
+//! command lets any TS caller mirror a tagged line into the file sink so
+//! `LAND_DEV_LOG=channel-stub,git tail -f Mountain.dev.log` captures both
+//! sides filtered identically.
+//!
+//! ## Contract
+//!
+//! - `Tag` is matched against `LAND_DEV_LOG` exactly as Rust tags are;
+//!   disabled tags produce no output (cheap no-op on the Mountain side).
+//! - `Message` is the fully-formatted log string - the caller has
+//!   already done any interpolation.
+//! - The command is fire-and-forget from the renderer's perspective
+//!   (returns `()` immediately); failures to write are swallowed.
+//! - Prefix `[RenderDevLog]` is added so grep can always separate
+//!   TS-originated lines from native `dev_log!` entries that share the
+//!   same tag.
+
+#![allow(non_snake_case)]
+
+use crate::dev_log;
+
+#[tauri::command]
+pub fn RenderDevLog(Tag:String, Message:String) {
+	// The `dev_log!` macro expands to a conditional on `IsEnabled(Tag)`
+	// - when the tag is off, the entire call is a no-op besides the
+	//   string allocation on the caller side. `$Tag:expr` in the macro
+	//   accepts `&str` / `&String` / `String` interchangeably.
+	let TagRef:&str = &Tag;
+	dev_log!(TagRef, "[RenderDevLog] {}", Message);
+}

Source/Binary/IPC/mod.rs

@@ -52,3 +52,4 @@ pub mod CacheStatsCommand;
 pub mod ProcessCommand;
 pub mod HealthCommand;
 pub mod WorkspaceFolderCommand;
+pub mod RenderDevLogCommand;

Source/Binary/Main/Entry.rs

@@ -553,6 +553,7 @@ pub fn Fn() {
 				crate::Binary::IPC::HealthCommand::cocoon_search_service_health,
 				crate::Binary::IPC::HealthCommand::cocoon_debug_service_health,
 				crate::Binary::IPC::HealthCommand::shared_process_service_health,
+				crate::Binary::IPC::RenderDevLogCommand::RenderDevLog,
 			])
 			.build(tauri::generate_context!())
 			.expect("FATAL: Error while building Mountain Tauri application")

Source/IPC/DevLog.rs

@@ -73,6 +73,21 @@
 //! | `cocoon`      | Cocoon sidecar: spawn, health, handshake             |
 //! | `bootstrap`   | Effect-TS bootstrap stages                           |
 //! | `preload`     | Preload: globals, polyfills, ipcRenderer             |
+//!
+//! ### Batch 1 diagnostic tags (Row 1-3 fix surfaces)
+//!
+//! Narrow tags added to isolate the architectural gaps surfaced by the
+//! analysis table. Enable selectively with e.g.
+//! `LAND_DEV_LOG=notif-drop,git,tree-view` to filter to just the
+//! subsystem under investigation.
+//!
+//! | Tag                 | Scope                                                                 |
+//! |---------------------|-----------------------------------------------------------------------|
+//! | `notif-drop`        | Notifications that hit the `_ => {}` default arm (dropped silently)   |
+//! | `provider-register` | Accepted `register_*_provider` notifications + handle + extension id  |
+//! | `channel-stub`      | Wind/Output `TauriMainProcessService.call` stub-hit vs route vs miss  |
+//! | `git`               | `localGit` channel, `GitExec` RPC, SCM provider group updates         |
+//! | `tree-view`         | `tree.register`, `GetTreeChildren`, `sky://tree-view/create` emit     |
 
 use std::{
 	fs::{File, OpenOptions, create_dir_all},

Source/RPC/CocoonService/SCM.rs

@@ -82,6 +82,16 @@ pub async fn UpdateScmGroup(Service:&CocoonServiceImpl, req:UpdateScmGroupReques
 
 pub async fn GitExec(Service:&CocoonServiceImpl, req:GitExecRequest) -> Result<Response<GitExecResponse>, Status> {
 	dev_log!("cocoon", "[CocoonService] git_exec: {}", req.args.join(" "));
+	dev_log!(
+		"git",
+		"[Git] exec-begin cwd={} args=[{}]",
+		if req.repository_path.is_empty() {
+			"<cwd>".to_string()
+		} else {
+			req.repository_path.clone()
+		},
+		req.args.join(" ")
+	);
 
 	let WorkingDir = if req.repository_path.is_empty() {
 		std::env::current_dir().unwrap_or_default()
@@ -96,6 +106,13 @@ pub async fn GitExec(Service:&CocoonServiceImpl, req:GitExecRequest) -> Result<R
 		.await
 		.map_err(|Error| {
 			dev_log!("cocoon", "error: [CocoonService] git_exec failed to spawn: {}", Error);
+			dev_log!(
+				"git",
+				"[Git] exec-spawn-fail cwd={:?} args=[{}] error={}",
+				WorkingDir,
+				req.args.join(" "),
+				Error
+			);
 			Status::internal(format!("git_exec: failed to spawn git: {}", Error))
 		})?;
 
@@ -107,6 +124,14 @@ pub async fn GitExec(Service:&CocoonServiceImpl, req:GitExecRequest) -> Result<R
 		Output.stdout.len(),
 		Output.stderr.len()
 	);
+	dev_log!(
+		"git",
+		"[Git] exec-done args=[{}] exit={} stdout={} stderr={}",
+		req.args.join(" "),
+		ExitCode,
+		Output.stdout.len(),
+		Output.stderr.len()
+	);
 
 	// Combine stdout lines into repeated string output; prepend stderr lines
 	// with "stderr: " prefix so extension can differentiate them.

Source/RPC/CocoonService/TreeView.rs

@@ -59,6 +59,12 @@ pub async fn GetTreeChildren(
 	req:GetTreeChildrenRequest,
 ) -> Result<Response<GetTreeChildrenResponse>, Status> {
 	dev_log!("cocoon", "[CocoonService] get_tree_children: view={}", req.view_id);
+	dev_log!(
+		"tree-view",
+		"[TreeView] get-children view={} parent_handle={} - STUB returns empty (Mountain→Cocoon round-trip not wired)",
+		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,

Source/Track/Effect/CreateEffectForRequest/TreeView.rs

@@ -64,6 +64,13 @@ pub fn CreateEffect<R:Runtime>(
 							DispatchAt.elapsed().as_millis(),
 							RegisteredNs
 						);
+						dev_log!(
+							"tree-view",
+							"[TreeView] register view={} result={} elapsed={}ms",
+							ViewIdForLog,
+							if Result.is_ok() { "ok" } else { "err" },
+							DispatchAt.elapsed().as_millis()
+						);
 
 						// Notify Wind/Sky that a data provider now exists for this
 						// view, so the renderer can set `treeView.dataProvider` on
@@ -87,6 +94,20 @@ pub fn CreateEffect<R:Runtime>(
 									ViewIdForLog,
 									Error
 								);
+								dev_log!(
+									"tree-view",
+									"[TreeView] emit-fail channel={} view={} error={}",
+									SkyEvent::TreeViewCreate.AsStr(),
+									ViewIdForLog,
+									Error
+								);
+							} else {
+								dev_log!(
+									"tree-view",
+									"[TreeView] emit-ok channel={} view={}",
+									SkyEvent::TreeViewCreate.AsStr(),
+									ViewIdForLog
+								);
 							}
 						}
 

Source/Vine/Server/MountainVinegRPCService.rs

@@ -838,6 +838,15 @@ impl MountainService for MountainVinegRPCService {
 					Handle,
 					Selector
 				);
+				dev_log!(
+					"provider-register",
+					"[ProviderRegister] accepted method={} type={} handle={} lang={} ext={}",
+					MethodName,
+					ProviderTypeName,
+					Handle,
+					Selector,
+					ExtId
+				);
 				// Provider registration happens in CocoonService.RegisterProvider via the typed
 				// RPC path. This notification path is a fallback for providers registered
 				// via the vscode API shim.
@@ -872,6 +881,22 @@ impl MountainService for MountainVinegRPCService {
 			},
 			_ => {
 				dev_log!("grpc", "[MountainVinegRPCService] Cocoon notification: {}", MethodName);
+				// No typed match arm exists for this notification - it hits
+				// the default path and becomes a `cocoon:<method>` Tauri
+				// event that Wind may or may not listen for. The
+				// `notif-drop` tag surfaces every fall-through so we can
+				// tell at a glance which notifications Cocoon emits that
+				// Mountain has no first-class handler for (register_*
+				// provider variants beyond the seven handled above,
+				// register_debug_adapter, register_task_provider,
+				// register_uri_handler, register_file_system_provider, …).
+				dev_log!(
+					"notif-drop",
+					"[NotifDrop] method={} payload_bytes={} (falls through to cocoon:{} event)",
+					MethodName,
+					NotificationData.parameter.len(),
+					MethodName
+				);
 				// Forward all unknown notifications as Tauri events so Wind
 				// can subscribe to any Cocoon-originated event.
 				let EventName = format!("cocoon:{}", MethodName);