fix(Mountain): Fix boot-time extensions race and add missing getLatency

Add polling to extensions:getInstalled to resolve boot-time race condition where workbench caches empty extension list before ExtensionPopulate completes its scan (~250-500ms). Poll the ScannedExtensions map for up to 3 seconds before returning empty, ensuring 113+ extension contributions appear in the activity bar.

Also add localPty:getLatency handler returning empty array per VS Code's IPtyHostLatencyMeasurement[] contract. Without this, every poll cycle logged "Unknown IPC command: localPty:getLatency" and a failed TauriInvoke.

Author: NikolaRHristov

Source/IPC/WindServiceHandlers/Extensions.rs

@@ -51,11 +51,56 @@ pub async fn handle_extensions_get_installed(
 ) -> Result<Value, String> {
 	let TypeFilter:Option<u8> = args.first().and_then(|V| V.as_u64()).map(|N| N as u8);
 
-	let Extensions = runtime
+	// Boot-time race fix: the workbench's `IExtensionService` calls
+	// `extensions:getInstalled` ~13 times during the first second of
+	// boot - reading an empty list because `ExtensionPopulate` runs
+	// in a parallel async task and only writes to ScannedExtensions
+	// AFTER its multi-path scan completes (~250-500ms in). The
+	// workbench caches that empty list, runs `viewsContainersExtension
+	// Point.setHandler([])`, and never re-processes contributions
+	// when the scan finishes - so the activity bar has zero
+	// extension-contributed icons (no Roo, Claude, gitlens panels)
+	// even though 113 extensions are scanned.
+	//
+	// Poll the map up to ~3 seconds before returning empty. The
+	// workbench's first call blocks for ~250-500ms (scan duration);
+	// every subsequent call sees the populated map immediately.
+	// 3s is the same ceiling as Mountain's lifecycle phase fallback,
+	// so this won't extend the visible boot delay beyond what's
+	// already there.
+	let mut Extensions = runtime
 		.Environment
 		.GetExtensions()
 		.await
 		.map_err(|Error| format!("extensions:getInstalled failed: {}", Error))?;
+	if Extensions.is_empty() {
+		const POLL_INTERVAL_MS:u64 = 50;
+		const MAX_WAIT_MS:u64 = 3000;
+		let mut Elapsed:u64 = 0;
+		while Extensions.is_empty() && Elapsed < MAX_WAIT_MS {
+			tokio::time::sleep(std::time::Duration::from_millis(POLL_INTERVAL_MS)).await;
+			Elapsed += POLL_INTERVAL_MS;
+			Extensions = runtime
+				.Environment
+				.GetExtensions()
+				.await
+				.map_err(|Error| format!("extensions:getInstalled failed: {}", Error))?;
+		}
+		if !Extensions.is_empty() {
+			dev_log!(
+				"extensions",
+				"extensions:getInstalled awaited scan completion ({}ms) - now has {} entries",
+				Elapsed,
+				Extensions.len()
+			);
+		} else {
+			dev_log!(
+				"extensions",
+				"warn: extensions:getInstalled timed out after {}ms; returning empty list",
+				Elapsed
+			);
+		}
+	}
 
 	let Wrapped:Vec<Value> = Extensions
 		.into_iter()

Source/IPC/WindServiceHandlers/mod.rs

@@ -1494,6 +1494,21 @@ pub async fn mountain_ipc_invoke(app_handle:AppHandle, command:String, args:Vec<
 					dev_log!("terminal", "localPty:getEnvironment");
 					handle_local_pty_get_environment().await
 				},
+				// `IPtyService.getLatency` (per
+				// `vs/platform/terminal/common/terminal.ts:341`) returns
+				// `IPtyHostLatencyMeasurement[]`. The workbench polls this
+				// to drive its "renderer ↔ pty host" health UI. We have
+				// no separate pty host (Mountain spawns PTYs in-process),
+				// so latency is effectively zero - return an empty array
+				// matching the "no measurements available" branch the
+				// workbench already handles. Without this route the call
+				// surfaced as `Unknown IPC command: localPty:getLatency`
+				// every poll cycle, and the renderer logged a
+				// `TauriInvoke ok=false` line per attempt.
+				"localPty:getLatency" => {
+					dev_log!("terminal", "localPty:getLatency");
+					Ok(json!([]))
+				},
 
 				// `cocoon:request` - generic renderer→Cocoon RPC bridge.
 				// Used by Sky-side bridges that need to dispatch a request