Start the window's session where dotnet fsi would, and only on .NET

The window picked its own fsi: `dotnet.exe` from Program Files, or one of the desktop executables the extension ships, chosen through the options page the old window reads. The desktop ones cannot serve the protocol at all — the server exists in the .NET fsi alone — and the machine-wide `dotnet` ignored the SDK a solution pins.

The session now starts in the open solution's folder with the `dotnet` a shell there would run, so the host resolves the SDK from that folder's `global.json` exactly as `dotnet fsi` typed at a prompt does, and the window runs the same compiler bits as `dotnet build`. The platform choice, the desktop executables and the shadow-copy switch stay with the old window. When a session comes up the window prints which fsi answered, on what runtime and where, so a pinned SDK is seen rather than guessed at.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: xperiandri

docs/ide/FSI-Modern-Interactive-Window-Plan.md

@@ -28,9 +28,10 @@ and contains:
 - `SubmissionAnalysis.fs` — the rule deciding when Enter submits, tested;
 - `FSharpVsInteractiveWindowProvider.fs` — the MEF component that creates the tool window through
   `IVsInteractiveWindowFactory.Create`, calls `SetLanguage` with the F# content type and language
-  service so the input buffer is an F# editor buffer, sets the caption from the platform, and reads
-  its options from the `SessionsProperties` the existing Tools, Options page already writes. No new
-  options page is needed.
+  service so the input buffer is an F# editor buffer, and reads its options from the
+  `SessionsProperties` the existing Tools, Options page already writes. No new options page is
+  needed. The session starts in the open solution's folder, so `dotnet fsi` runs the SDK that
+  folder's `global.json` resolves to.
 
 Still to do before the window can be opened in Visual Studio:
 
@@ -40,7 +41,7 @@ Still to do before the window can be opened in Visual Studio:
   calls the provider, rather than a new package with its own GUID and pkgdef;
 - the `Microsoft.VisualStudio.InteractiveWindow` prerequisite entry in the VSIX manifest, and the
   project's place in the VSIX itself. It is already in `VisualFSharp.slnx`, so it builds;
-- commands: open the window, `#reset <platform>`, and retargeting Alt+Enter at the new window;
+- commands: open the window, and retargeting Alt+Enter at the new window;
 - the debugger attach/detach commands ported from the existing window. The session reports its own
   process id in the handshake, so the attach no longer has to guess which process to target.
 
@@ -76,7 +77,7 @@ What the old window does have that C# Interactive does **not** (must be preserve
 
 - **Debugging**: attach/detach the VS debugger to the FSI process, "Debug in Interactive" (`#dbgbreak`), debuggability check (`--debug+ --optimize-`) with a suppressible warning dialog. Roslyn's window has no debugging at all — this is an F# advantage to keep.
 - Real script semantics: FSI executes actual `.fsx` interactions with `#load`/`#r`/`#i`, and `fsi` object, not a C#-script dialect.
-- Platform choice already includes Arm64 (`fsiArm64.exe`).
+- The .NET Framework hosts (`fsiAnyCpu.exe`, `fsi.exe`, `fsiArm64.exe`) stay with the old window; the new one is .NET-only, because the server mode exists only in the .NET fsi.
 
 ---
 
@@ -113,8 +114,7 @@ Five layers, copied from Roslyn's proven separation. Execution state lives **onl
                                │ + redirected stdout/stderr (user output)
 ┌──────────────────────────────▼────────────────────────────────────────┐
 │ EXECUTION HOST = fsi itself, in a new server mode                     │
-│ dotnet fsi --fsi-server-jsonrpc:<pipe>           (.NET / SDK)         │
-│ fsiAnyCpu.exe / fsiArm64.exe --fsi-server-jsonrpc:…  (.NET Framework) │
+│ dotnet fsi --fsi-server-jsonrpc:<pipe>  (the SDK global.json resolves) │
 │ FsiEvaluationSession driven by RPC instead of the stdin ReadLine loop │
 └───────────────────────────────────────────────────────────────────────┘
 ```
@@ -125,7 +125,7 @@ Roslyn ships dedicated `InteractiveHost64/32.exe` binaries because C# scripting
 
 - kills the `SERVER-PROMPT>` scraping, the PID-file hack, and the `# 1 "stdin"` directive juggling in one move;
 - benefits every other fsi client (Ionide, VS Code, custom tooling) — the server mode is a compiler feature, not a VS-only one;
-- keeps `dotnet fsi` as the .NET Core host (nothing new to deploy; the VSIX only carries the desktop `fsiAnyCpu`/`fsiArm64` it already ships).
+- keeps `dotnet fsi` as the host, resolved from the solution folder's `global.json`, so the window runs the same compiler bits as `dotnet build` there and Visual Studio and SDK versions are decoupled (nothing new to deploy; the desktop `fsiAnyCpu`/`fsiArm64` the VSIX ships stay with the old window).
 
 ### 2.2 The RPC protocol (as implemented)
 
@@ -195,18 +195,11 @@ The single most valuable user-facing change. Mechanism (Roslyn's, adapted):
 - Otherwise → submit iff the text is a syntactically complete interaction (FCS parse with `ScriptParseInfo`; incomplete constructs — open `let`, unclosed paren/string — return false). This matches `dotnet fsi`'s modern multiline behavior and C#'s `SyntaxFactory.IsCompleteSubmission`.
 - The evaluator appends `;;` before sending to the host if absent; prompts: `> ` primary, `. ` (or `- `) continuation via `GetPrompt()`.
 
-### 2.5 Platform selection
+### 2.5 Host selection
 
-Keep today's matrix, expressed the Roslyn way (`#reset` arguments + caption suffix + options page default):
+The window is .NET-only. The server mode exists in the .NET fsi alone, and the desktop matrix (`fsiAnyCpu.exe`, `fsi.exe`, `fsiArm64.exe`, `#reset` platform arguments, the shadow-copy switch) stays with the old window until that is retired.
 
-| Platform | Host | Notes |
-|---|---|---|
-| .NET (default) | `dotnet fsi` | SDK-resolved; caption "F# Interactive (.NET)" |
-| .NET Framework x64 | `fsiAnyCpu.exe --fsi-server-jsonrpc:…` | shipped in VSIX |
-| .NET Framework x86 | `fsi.exe` | shipped in VSIX |
-| Arm64 | `fsiArm64.exe` | shipped in VSIX |
-
-`#reset core` / `#reset net472` / etc. exported as a specialized-content-type command that displaces the package's generic `#reset` (Roslyn's `GetApplicableCommands` name-replacement mechanism).
+The session is started in the open solution's folder, with the `dotnet` a shell there would run (`DOTNET_HOST_PATH`, then `PATH`, then the machine-wide install). The host resolves the SDK from that folder's `global.json` exactly as `dotnet fsi` typed in a shell would, so the window runs the same compiler bits as `dotnet build`, and Visual Studio and SDK versions are decoupled. Nothing in the window re-implements SDK resolution. `FSHARP_INTERACTIVE_PATH` names another fsi for development, until an SDK ships the protocol; the window prints which fsi answered, on what runtime and in which directory, when a session comes up.
 
 ### 2.6 Debugging (parity + improvement over C#)
 
@@ -243,7 +236,7 @@ Goal: de-risk the InteractiveWindow dependency before touching the compiler.
 ### Phase 2 — Evaluator + session on the new protocol — partly done
 
 - `FSharpInteractiveSession`: single `AsyncBatchingWorkQueue`-style queue serializing init/execute/set-paths (reset preempts); `LazyRemoteService` lifecycle port; auto-restart; pending-buffer queue.
-- Full `IInteractiveEvaluator`: `CanExecuteCode` (§2.4), `GetPrompt`, `ResetAsync` with platform args, `InitializeAsync`, `AbortExecution` → RPC `Interrupt` (note: this makes F# *better* than C# Interactive, whose `AbortExecution` is an unimplemented TODO).
+- Full `IInteractiveEvaluator`: `CanExecuteCode` (§2.4), `GetPrompt`, `ResetAsync`, `InitializeAsync`, `AbortExecution` → RPC `Interrupt` (note: this makes F# *better* than C# Interactive, whose `AbortExecution` is an unimplemented TODO).
 - Structured diagnostics from `ExecutionResult` rendered as error-classified output.
 - Delete the stdin/stdout path from the new window (old window untouched).
 
@@ -260,9 +253,9 @@ Goal: de-risk the InteractiveWindow dependency before touching the compiler.
 
 - Rewire `MenusAndCommands.vsct` targets: Alt+Enter Send Selection/Line, "Execute in Interactive", "Debug in Interactive" → new window (`window.SubmitAsync`, preserving the no-selection→current-line + caret-advance behavior; consider Roslyn's syntax-aware selection expansion from `SendToInteractiveSubmissionProvider`).
 - `AddReferences` (Solution Explorer "Send project references to F# Interactive") → `#r` submissions.
-- Optional: "Initialize Interactive with Project" parity — build project, reset with platform inferred from TFM, `SetPaths`, `#r` output assembly + references, `open` default namespaces (Roslyn's `ResetInteractive` flow).
-- Port `FsiPropertyPage` (Tools → Options → F# Tools → F# Interactive): args, platform default, shadow copy (`--shadowcopyreferences` still honored via args), langversion preview, debug mode.
-- Window caption platform suffix; `#reset` platform args; F1 help keyword.
+- Optional: "Initialize Interactive with Project" parity — build project, reset, `SetPaths`, `#r` output assembly + references, `open` default namespaces (Roslyn's `ResetInteractive` flow).
+- Port `FsiPropertyPage` (Tools → Options → F# Tools → F# Interactive): args, langversion preview, debug mode. The platform default and shadow copy belong to the desktop fsi and stay with the old window.
+- F1 help keyword.
 
 ### Phase 5 — Debugging parity (1–2 weeks)
 

vsintegration/src/FSharp.Interactive.Window/FSharpInteractiveEvaluator.fs

@@ -34,21 +34,20 @@ module internal ResultRendering =
     let formatDiagnostic (diagnostic: FSharp.Compiler.Interactive.Protocol.DiagnosticInfo) =
         $"{diagnostic.fileName}({diagnostic.startLine},{diagnostic.startColumn + 1}): {diagnostic.severity} FS%04d{diagnostic.errorNumber}: {diagnostic.message}"
 
+    /// The line the window shows when a session comes up: which fsi answered, on what, and where.
+    let formatSessionStart (session: FSharp.Compiler.Interactive.Protocol.InitializeResult) =
+        $"F# Interactive {session.fsiVersion} on {session.frameworkDescription}, in {session.workingDirectory}"
+
 /// Connects the interactive window to an F# Interactive session.
 [<Sealed>]
-type internal FSharpInteractiveEvaluator
-    (
-        host: InteractiveHostClient,
-        getOptions: unit -> InteractiveHostOptions,
-        onPlatformChanged: InteractiveHostPlatform -> unit
-    ) =
+type internal FSharpInteractiveEvaluator(host: InteractiveHostClient, getOptions: unit -> InteractiveHostOptions) =
 
     let mutable currentWindow: IInteractiveWindow | null = null
     let mutable outputSubscription: IDisposable | null = null
     let mutable errorSubscription: IDisposable | null = null
     let mutable exitedSubscription: IDisposable | null = null
+    let mutable startedSubscription: IDisposable | null = null
     let mutable disposed = false
-    let mutable requestedPlatform: InteractiveHostPlatform voption = ValueNone
 
     // The window submits text without saying where it came from, so an editor command records the
     // origin here for the submission it is about to make. Both run on the UI thread.
@@ -61,6 +60,11 @@ type internal FSharpInteractiveEvaluator
         | null -> ()
         | window -> window.OutputWriter.Write text
 
+    let writeLine (text: string) =
+        match currentWindow with
+        | null -> ()
+        | window -> window.OutputWriter.WriteLine text
+
     let writeError (text: string) =
         match currentWindow with
         | null -> ()
@@ -71,13 +75,6 @@ type internal FSharpInteractiveEvaluator
         | null -> ()
         | window -> window.ErrorOutputWriter.WriteLine text
 
-    let optionsForNextSession () =
-        let options = getOptions ()
-
-        match requestedPlatform with
-        | ValueSome platform -> { options with Platform = platform }
-        | ValueNone -> options
-
     let reportDiagnostics (result: FSharp.Compiler.Interactive.Protocol.ExecutionResult) =
         match result.diagnostics with
         | null -> ()
@@ -95,7 +92,7 @@ type internal FSharpInteractiveEvaluator
 
     let ensureSessionAsync () =
         task {
-            match! host.EnsureStartedAsync(optionsForNextSession ()) with
+            match! host.EnsureStartedAsync(getOptions ()) with
             | Result.Ok _ -> return true
             | Result.Error message ->
                 writeErrorLine message
@@ -110,12 +107,8 @@ type internal FSharpInteractiveEvaluator
     let reportSessionExit exitCode =
         writeErrorLine $"{VFSIstrings.SR.sessionTerminationDetected()} (exit code {exitCode})"
 
-    member _.CurrentPlatform =
-        match requestedPlatform with
-        | ValueSome platform -> platform
-        | ValueNone -> (getOptions ()).Platform
-
-    member _.RequestPlatform platform = requestedPlatform <- ValueSome platform
+    let reportSessionStart session =
+        writeLine (ResultRendering.formatSessionStart session)
 
     /// Attribute the next submission to a file and line, so that its diagnostics land on the user's
     /// own source rather than on the submission.
@@ -140,6 +133,7 @@ type internal FSharpInteractiveEvaluator
                 unsubscribe outputSubscription
                 unsubscribe errorSubscription
                 unsubscribe exitedSubscription
+                unsubscribe startedSubscription
 
                 match window with
                 | null -> ()
@@ -148,6 +142,7 @@ type internal FSharpInteractiveEvaluator
                     outputSubscription <- host.OutputReceived.Subscribe write
                     errorSubscription <- host.ErrorOutputReceived.Subscribe writeError
                     exitedSubscription <- host.ProcessExited.Subscribe reportSessionExit
+                    startedSubscription <- host.SessionStarted.Subscribe reportSessionStart
 
         member _.InitializeAsync() =
             task {
@@ -159,10 +154,7 @@ type internal FSharpInteractiveEvaluator
         // session has none to vary, and the flag never means "do not start a replacement".
         member _.ResetAsync(_initialize) =
             task {
-                let options = optionsForNextSession ()
-                onPlatformChanged options.Platform
-
-                match! host.ResetAsync options with
+                match! host.ResetAsync(getOptions ()) with
                 | Result.Ok _ -> return ExecutionResult true
                 | Result.Error message ->
                     writeErrorLine message
@@ -221,4 +213,5 @@ type internal FSharpInteractiveEvaluator
                 unsubscribe outputSubscription
                 unsubscribe errorSubscription
                 unsubscribe exitedSubscription
+                unsubscribe startedSubscription
                 (host :> IDisposable).Dispose()

vsintegration/src/FSharp.Interactive.Window/FSharpVsInteractiveWindowProvider.fs

@@ -6,7 +6,6 @@ open System
 open System.ComponentModel.Composition
 open System.Diagnostics
 open System.IO
-open System.Runtime.InteropServices
 open System.Threading
 
 open Microsoft.VisualStudio
@@ -38,25 +37,36 @@ module InteractiveWindowGuids =
 /// Reads the session settings the existing Tools, Options page writes.
 module internal InteractiveHostOptionsFactory =
 
-    let private hostDirectory () =
-        match Path.GetDirectoryName(typeof<InteractiveHostClient>.Assembly.Location) with
-        | null -> Environment.CurrentDirectory
-        | directory -> directory
-
-    let currentPlatform () =
-        match SessionsProperties.fsiUseNetCore, RuntimeInformation.ProcessArchitecture with
-        | true, _ -> NetCore
-        | _, Architecture.Arm64 -> NetFrameworkArm64
-        | _ when SessionsProperties.useAnyCpuVersion -> NetFramework64
-        | _ -> NetFramework32
-
-    let create platform =
+    /// The folder `dotnet fsi` is run from: the open solution's, whose `global.json` then picks the
+    /// SDK; the user's profile when nothing is open. Read on the UI thread, where the window's
+    /// evaluator calls in.
+    let private startDirectory () =
+        let solutionDirectory =
+            try
+                match ServiceProvider.GlobalProvider.GetService typeof<SVsSolution> with
+                | :? IVsSolution as solution ->
+                    let hr, directory, _, _ = solution.GetSolutionInfo()
+
+                    if
+                        ErrorHandler.Succeeded hr
+                        && not (String.IsNullOrEmpty directory)
+                        && Directory.Exists directory
+                    then
+                        ValueSome directory
+                    else
+                        ValueNone
+                | _ -> ValueNone
+            with _ ->
+                ValueNone
+
+        match solutionDirectory with
+        | ValueSome directory -> directory
+        | ValueNone -> Environment.GetFolderPath Environment.SpecialFolder.UserProfile
+
+    let create () =
         {
-            Platform = platform
-            HostDirectory = hostDirectory ()
-            InitialWorkingDirectory = Environment.GetFolderPath Environment.SpecialFolder.UserProfile
+            InitialWorkingDirectory = startDirectory ()
             UserArguments = SessionsProperties.fsiArgs
-            ShadowCopyReferences = SessionsProperties.fsiShadowCopy
             DebugMode = SessionsProperties.fsiDebugMode
             LanguageVersionPreview = SessionsProperties.fsiPreview
             UICultureLcid = Thread.CurrentThread.CurrentUICulture.LCID
@@ -72,27 +82,16 @@ type internal FSharpVsInteractiveWindowProvider
     let mutable window: IVsInteractiveWindow | null = null
     let mutable evaluator: FSharpInteractiveEvaluator voption = ValueNone
 
-    let captionFor (platform: InteractiveHostPlatform) =
-        $"{VFSIstrings.SR.fsharpInteractive ()} ({platform.Description})"
-
-    let setCaption platform =
-        match box window with
-        | :? ToolWindowPane as pane -> pane.Caption <- captionFor platform
-        | _ -> ()
-
-    let currentOptions () =
-        InteractiveHostOptionsFactory.create (InteractiveHostOptionsFactory.currentPlatform ())
-
     member this.Create(instanceId: int) =
         let host = new InteractiveHostClient(Process.GetCurrentProcess().Id)
-        let created = new FSharpInteractiveEvaluator(host, currentOptions, setCaption)
+        let created = new FSharpInteractiveEvaluator(host, InteractiveHostOptionsFactory.create)
         evaluator <- ValueSome created
 
         let toolWindow =
             windowFactory.Create(
                 InteractiveWindowGuids.ToolWindowId,
                 instanceId,
-                captionFor (InteractiveHostOptionsFactory.currentPlatform ()),
+                VFSIstrings.SR.fsharpInteractive (),
                 created,
                 __VSCREATETOOLWIN.CTW_fForceCreate
             )