fix(Mountain): Implement extension type filtering and post-install activation

Three related fixes address the "install succeeded but nothing happened" symptom:

1. **Extension type filtering** (`Extensions.rs`): VS Code's `getInstalled(type?)` IPC passes an optional `ExtensionType` filter (0=System, 1=User). Previously this filter was silently dropped and every call returned the full list as `type: 0, isBuiltin: true`. Now the handler respects the filter and properly distinguishes VSIX-installed extensions from built-ins based on the scanner's `isBuiltin` field.

2. **Post-install activation burst** (`Extension.rs`): After `$deltaExtensions` adds an extension to Cocoon's registry, we now fire `onStartupFinished` activation events. Without this burst, extensions with `onStartupFinished` (like `Anthropic.claude-code`) register but never activate - their sidebar contributions and commands silently no-op until the next full workbench restart.

3. **Sidebar scan handlers** (`mod.rs`): Forward `extensions:scanSystemExtensions` → `getInstalled(type=0)` and `extensions:scanUserExtensions` → `getInstalled(type=1)`. The VS Code channel client doesn't always pass explicit type filters, so the override ensures User extensions appear under "Installed" with an Uninstall action.

Impact: VSIX extensions now show under "Installed" with Uninstall, activate immediately after install without reload, and the Extensions sidebar refresh works correctly.

Author: NikolaRHristov

Source/IPC/WindServiceHandler/Extension.rs

@@ -24,9 +24,34 @@ const COCOON_SIDE_CAR_IDENTIFIER:&str = "cocoon-main";
 /// blocked on a stalled extension host.
 const COCOON_DELTA_TIMEOUT_MS:u64 = 10_000;
 
-/// Tell Cocoon to diff the extension registry by the provided descriptors.
-/// Fire-and-forget: a missing Cocoon (LAND_SPAWN_COCOON=false) or a transient
-/// RPC failure is logged but does not fail the install/uninstall IPC call.
+/// Tell Cocoon to diff the extension registry by the provided descriptors,
+/// then fire the "already-satisfied" activation events on the result so
+/// newly-added extensions activate without a workbench reload.
+///
+/// Fire-and-forget: a missing Cocoon (LAND_SPAWN_COCOON=false) or a
+/// transient RPC failure is logged but does not fail the install/uninstall
+/// IPC call.
+///
+/// # Why the follow-up `$activateByEvent` burst
+///
+/// `$deltaExtensions` adds the extension to Cocoon's registry and indexes
+/// its `activationEvents`, but it does **not** fire those events. The
+/// workbench boots by emitting `$activateByEvent("*")` exactly once; any
+/// extension installed after that point never sees its startup events
+/// re-fired. Without this burst a VSIX with `onStartupFinished` (the most
+/// common activation trigger used by tool-extensions like
+/// `Anthropic.claude-code`) registers but never activates - its sidebar
+/// contributions, commands and webview panels all silently no-op until
+/// the next full boot, which is exactly the "install succeeded but
+/// nothing happened" symptom.
+///
+/// We fire the events we know are currently satisfied: `"*"` (always
+/// satisfied) and `"onStartupFinished"` (satisfied once Mountain has
+/// crossed lifecycle phase Ready, which is true by the time any user
+/// interaction - including "Install from VSIX…" - could have reached
+/// this handler). `workspaceContains:*` activation is handled Cocoon-side
+/// by `WorkspaceContainsActivator`, which subscribes to the
+/// `deltaExtensions` emitter and re-scans automatically.
 fn NotifyCocoonDeltaExtensions(ToAdd:Vec<Value>, ToRemove:Vec<Value>) {
 	tokio::spawn(async move {
 		let Parameters = json!({
@@ -49,8 +74,53 @@ fn NotifyCocoonDeltaExtensions(ToAdd:Vec<Value>, ToRemove:Vec<Value>) {
 				// Non-fatal - most commonly hit when Cocoon is intentionally
 				// off (LAND_SPAWN_COCOON=false) or still booting.
 				dev_log!("extensions", "warn: $deltaExtensions failed (non-fatal): {}", Error);
+				// Skip the activation burst when delta itself failed: firing
+				// activation events against a Cocoon that didn't receive the
+				// registry update would match zero extensions and waste two
+				// round-trips per install.
+				return;
 			},
 		}
+
+		// Activation events are sent sequentially (not spawned in parallel)
+		// so they observe the registry state that `$deltaExtensions` just
+		// committed. Only `onStartupFinished` is fired here - it is the
+		// one event that's guaranteed to be already satisfied by the time
+		// user interaction could reach the install handler (lifecycle
+		// phase is past `Ready`). Firing Cocoon's `"*"` pseudo-event
+		// would over-activate: Cocoon treats `"*"` as "collect every
+		// extension that declares any activation event", which would
+		// eagerly load lazy-activation extensions like
+		// `onLanguage:python` or `onCommand:foo` that should stay dormant
+		// until their real trigger fires.
+		for Event in ["onStartupFinished"] {
+			let ActivationParameters = json!({ "activationEvent": Event });
+			match Vine::Client::SendRequest(
+				&COCOON_SIDE_CAR_IDENTIFIER.to_string(),
+				"$activateByEvent".to_string(),
+				ActivationParameters,
+				COCOON_DELTA_TIMEOUT_MS,
+			)
+			.await
+			{
+				Ok(Response) => {
+					dev_log!(
+						"extensions",
+						"$activateByEvent({}) post-delta applied: {}",
+						Event,
+						Response
+					);
+				},
+				Err(Error) => {
+					dev_log!(
+						"extensions",
+						"warn: $activateByEvent({}) post-delta failed (non-fatal): {}",
+						Event,
+						Error
+					);
+				},
+			}
+		}
 	});
 }
 

Source/IPC/WindServiceHandlers/Extensions.rs

@@ -13,11 +13,48 @@ use crate::{
 	dev_log,
 };
 
+/// VS Code's `ExtensionType` enum - mirror the numeric values used by the
+/// renderer's `getInstalled(type?)` IPC so the filter in `GetInstalledArgs`
+/// matches what the channel client sends.
+///
+/// `src/vs/platform/extensions/common/extensions.ts` in the pinned VS Code
+/// dependency:
+/// ```ts
+/// export const enum ExtensionType { System = 0, User = 1 }
+/// ```
+const EXTENSION_TYPE_SYSTEM:u8 = 0;
+const EXTENSION_TYPE_USER:u8 = 1;
+
 /// Return scanned extensions reshaped as VS Code's `ILocalExtension[]`
 /// so `ExtensionManagementChannelClient.getInstalled` can destructure
 /// `extension.identifier.id`, `extension.manifest.*`, and
 /// `extension.location` without blowing up.
-pub async fn handle_extensions_get_installed(runtime:Arc<ApplicationRunTime>) -> Result<Value, String> {
+///
+/// # Argument contract
+///
+/// `args[0]` is the optional `ExtensionType` filter VS Code passes in:
+/// - `0` (System) → only return built-in extensions.
+/// - `1` (User) → only return VSIX-installed extensions.
+/// - `null` / missing → return every known extension.
+///
+/// Previously this filter was silently dropped and every call returned the
+/// full list hardcoded as `type: 0, isBuiltin: true`. That produced three
+/// cascading symptoms:
+///   1. VSIX-installed extensions (e.g. `Anthropic.claude-code`) showed up
+///      under "Built-in" in the Extensions sidebar and had no Uninstall
+///      action because the UI keys off `type === User`.
+///   2. The trusted-publishers boot migration iterated every extension as
+///      User and attempted `manifest.publisher.toLowerCase()` against
+///      System manifests.
+///   3. `extensions:scanUserExtensions` (which shares the user-only
+///      semantic) returned zero, making the "Install from VSIX…" refresh
+///      appear to do nothing even when the install itself succeeded.
+pub async fn handle_extensions_get_installed(
+	runtime:Arc<ApplicationRunTime>,
+	args:Vec<Value>,
+) -> Result<Value, String> {
+	let TypeFilter:Option<u8> = args.first().and_then(|V| V.as_u64()).map(|N| N as u8);
+
 	let Extensions = runtime
 		.Environment
 		.GetExtensions()
@@ -26,7 +63,20 @@ pub async fn handle_extensions_get_installed(runtime:Arc<ApplicationRunTime>) ->
 
 	let Wrapped:Vec<Value> = Extensions
 		.into_iter()
-		.map(|Manifest| {
+		.filter_map(|Manifest| {
+			// `isBuiltin` is authored by the scanner; default to `true` for
+			// safety when the field is missing (matches the pre-filter
+			// hardcoded behaviour so we never drop an extension the renderer
+			// used to see).
+			let IsBuiltin = Manifest.get("isBuiltin").and_then(Value::as_bool).unwrap_or(true);
+			let ExtensionType = if IsBuiltin { EXTENSION_TYPE_SYSTEM } else { EXTENSION_TYPE_USER };
+
+			if let Some(Wanted) = TypeFilter {
+				if Wanted != ExtensionType {
+					return None;
+				}
+			}
+
 			let Publisher = Manifest
 				.get("publisher")
 				.and_then(Value::as_str)
@@ -71,10 +121,10 @@ pub async fn handle_extensions_get_installed(runtime:Arc<ApplicationRunTime>) ->
 				Map.entry("version".to_string()).or_insert_with(|| json!("0.0.0"));
 			}
 
-			json!({
+			Some(json!({
 				// IExtension (base)
-				"type": 0, // ExtensionType.System
-				"isBuiltin": true,
+				"type": ExtensionType,
+				"isBuiltin": IsBuiltin,
 				"identifier": { "id": Id },
 				"manifest": Manifest,
 				"location": Location,
@@ -93,15 +143,20 @@ pub async fn handle_extensions_get_installed(runtime:Arc<ApplicationRunTime>) ->
 				"updated": false,
 				"pinned": false,
 				"forceAutoUpdate": false,
-				"source": "system",
+				// `source` distinguishes the disk origin: built-ins ship with
+				// the bundle ("system"); VSIX-installed extensions live under
+				// `~/.land/extensions/*` ("vsix"). The sidebar keys off this
+				// for the "Uninstall" gesture.
+				"source": if IsBuiltin { "system" } else { "vsix" },
 				"size": 0,
-			})
+			}))
 		})
 		.collect();
 
 	dev_log!(
 		"extensions",
-		"extensions:getInstalled returning {} ILocalExtension-shaped entries",
+		"extensions:getInstalled type={:?} returning {} ILocalExtension-shaped entries",
+		TypeFilter,
 		Wrapped.len()
 	);
 

Source/IPC/WindServiceHandlers/mod.rs

@@ -300,12 +300,47 @@ pub async fn mountain_ipc_invoke(app_handle:AppHandle, command:String, args:Vec<
 						.collect::<Vec<_>>()
 						.join(" ");
 					dev_log!("extensions", "{} args={}", command, ArgsSummary);
-					handle_extensions_get_installed(runtime.clone()).await
+					// `scanSystemExtensions` is conceptually
+					// `getInstalled(type=ExtensionType.System)`, so override
+					// `args[0]` to `0` before forwarding. Without the override
+					// a plain alias would inherit whatever the caller passed
+					// in args[0] (which for the VS Code channel client is
+					// usually `null`) and leak User extensions into the
+					// System list - the same bug we just fixed at the
+					// handler layer, one level up.
+					let EffectiveArgs = if command == "extensions:scanSystemExtensions" {
+						let mut Overridden = args.clone();
+						if Overridden.is_empty() {
+							Overridden.push(Value::Null);
+						}
+						Overridden[0] = json!(0);
+						Overridden
+					} else {
+						args.clone()
+					};
+					handle_extensions_get_installed(runtime.clone(), EffectiveArgs).await
+				},
+				"extensions:scanUserExtensions" => {
+					// User-scope scan. Forward to the unified handler with
+					// `type=ExtensionType.User (1)` so VSIX-installed
+					// extensions under `~/.land/extensions/*` come back
+					// even when the caller didn't pass an explicit type
+					// filter (VS Code's channel client does that on
+					// scan-user-extensions, which is why the sidebar
+					// previously saw an empty list after every
+					// Install-from-VSIX).
+					dev_log!("extensions", "{} (forwarded to getInstalled with type=User)", command);
+					let mut UserArgs = args.clone();
+					if UserArgs.is_empty() {
+						UserArgs.push(Value::Null);
+					}
+					UserArgs[0] = json!(1);
+					handle_extensions_get_installed(runtime.clone(), UserArgs).await
 				},
-				"extensions:scanUserExtensions" | "extensions:getUninstalled" => {
-					// Land doesn't support user-installed extensions yet - the
-					// workbench treats an empty array as "no user extensions",
-					// which is correct for the current Mountain architecture.
+				"extensions:getUninstalled" => {
+					// Uninstalled state (extensions soft-deleted but kept in
+					// the profile) isn't tracked yet; an empty array is the
+					// correct "nothing pending uninstall" response.
 					dev_log!("extensions", "{} (returning [])", command);
 					Ok(Value::Array(Vec::new()))
 				},