@@ -5,6 +5,7 @@ package data
 import (
 	"io"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"sync"
 
@@ -51,6 +52,11 @@ func startPTY(binary string) (io.ReadWriteCloser, error) {
 
 // findCopilotBinary returns the path to copilot.exe on Windows.
 func findCopilotBinary() string {
+	// Try PATH first (matches Unix behavior).
+	if p, err := exec.LookPath("copilot"); err == nil {
+		return p
+	}
+
 	candidates := []string{
 		filepath.Join(os.Getenv("ProgramFiles"), "nodejs", "node_modules",
 			"@github", "copilot", "node_modules", "@github", "copilot-win32-x64", "copilot.exe"),
 
@@ -166,9 +166,10 @@ func TestLastReindexTime_EmptyWAL(t *testing.T) {
 // ---------------------------------------------------------------------------
 
 func TestFindCopilotBinary_NoCandidates(t *testing.T) {
-	// Set environment to non-existent paths.
+	// Set environment to non-existent paths and isolate PATH.
 	t.Setenv("ProgramFiles", filepath.Join(t.TempDir(), "nonexistent"))
 	t.Setenv("APPDATA", "")
+	t.Setenv("PATH", t.TempDir())
 
 	got := findCopilotBinary()
 	if got != "" {
@@ -179,6 +180,7 @@ func TestFindCopilotBinary_NoCandidates(t *testing.T) {
 func TestFindCopilotBinary_WithAPPDATA(t *testing.T) {
 	tmp := t.TempDir()
 	t.Setenv("ProgramFiles", filepath.Join(tmp, "nonexistent"))
+	t.Setenv("PATH", filepath.Join(tmp, "emptypath"))
 
 	// Create the APPDATA candidate path.
 	appdata := filepath.Join(tmp, "appdata")
@@ -206,6 +208,7 @@ func TestFindCopilotBinary_WithProgramFiles(t *testing.T) {
 	progFiles := filepath.Join(tmp, "Program Files")
 	t.Setenv("ProgramFiles", progFiles)
 	t.Setenv("APPDATA", "")
+	t.Setenv("PATH", filepath.Join(tmp, "emptypath"))
 
 	candidatePath := filepath.Join(progFiles, "nodejs", "node_modules",
 		"@github", "copilot", "node_modules", "@github", "copilot-win32-x64")
@@ -223,6 +226,28 @@ func TestFindCopilotBinary_WithProgramFiles(t *testing.T) {
 	}
 }
 
+func TestFindCopilotBinary_ViaPath(t *testing.T) {
+	tmp := t.TempDir()
+	t.Setenv("ProgramFiles", filepath.Join(tmp, "nonexistent"))
+	t.Setenv("APPDATA", "")
+
+	// Place a copilot.exe on PATH.
+	binDir := filepath.Join(tmp, "bin")
+	if err := os.MkdirAll(binDir, 0o755); err != nil {
+		t.Fatalf("creating bin dir: %v", err)
+	}
+	fakeBinary := filepath.Join(binDir, "copilot.exe")
+	if err := os.WriteFile(fakeBinary, []byte("fake"), 0o755); err != nil {
+		t.Fatalf("writing fake binary: %v", err)
+	}
+	t.Setenv("PATH", binDir)
+
+	got := findCopilotBinary()
+	if got != fakeBinary {
+		t.Errorf("findCopilotBinary() = %q, want %q", got, fakeBinary)
+	}
+}
+
 // ---------------------------------------------------------------------------
 // Maintain — 56% coverage, test error branches
 // ---------------------------------------------------------------------------
 
@@ -8,6 +8,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+	"sync"
 )
 
 const (
@@ -58,20 +59,30 @@ func SessionStorePath() (string, error) {
 const wslMountRoot = "/mnt/c/Users"
 
 // isWSL reports whether the current process is running inside Windows
-// Subsystem for Linux.
+// Subsystem for Linux. The result is cached after the first call since
+// the WSL status cannot change during a process lifetime.
 func isWSL() bool {
-	// WSL2 (and recent WSL1) always set WSL_DISTRO_NAME.
-	if os.Getenv("WSL_DISTRO_NAME") != "" {
-		return true
-	}
-	// Older WSL1 may not set the env var; fall back to /proc/version.
-	data, err := os.ReadFile("/proc/version")
-	if err != nil {
-		return false
-	}
-	return strings.Contains(strings.ToLower(string(data)), "microsoft")
+	wslOnce.Do(func() {
+		// WSL2 (and recent WSL1) always set WSL_DISTRO_NAME.
+		if os.Getenv("WSL_DISTRO_NAME") != "" {
+			wslCached = true
+			return
+		}
+		// Older WSL1 may not set the env var; fall back to /proc/version.
+		data, err := os.ReadFile("/proc/version")
+		if err != nil {
+			return
+		}
+		wslCached = strings.Contains(strings.ToLower(string(data)), "microsoft")
+	})
+	return wslCached
 }
 
+var (
+	wslOnce   sync.Once
+	wslCached bool
+)
+
 // findWindowsSessionStore scans Windows user-profile directories under the
 // default WSL mount for a Copilot session store database.
 func findWindowsSessionStore() string {
 
@@ -332,6 +332,13 @@ func DefaultTerminal() string {
 	case "darwin":
 		return "Terminal.app"
 	default:
+		// Inside WSL, prefer Windows Terminal when wt.exe is available
+		// since it's the terminal the user is actually sitting in.
+		if isWSL() {
+			if _, err := exec.LookPath("wt.exe"); err == nil {
+				return termWindowsTerminal
+			}
+		}
 		if terms := detectLinuxTerminals(); len(terms) > 0 {
 			return terms[0].Name
 		}
@@ -371,7 +378,7 @@ func LaunchSession(shell ShellInfo, sessionID string, cfg ResumeConfig) error {
 	case "darwin":
 		return launchDarwinSession(shell, resumeCmd, cfg.Terminal, cwd, cfg.LaunchStyle == LaunchStyleWindow)
 	default:
-		return launchLinuxSession(shell, resumeCmd, cfg.Terminal, cwd)
+		return launchLinuxSession(shell, resumeCmd, cfg.Terminal, cwd, cfg.LaunchStyle, cfg.PaneDirection)
 	}
 }
 
@@ -672,7 +679,12 @@ func escapeAppleScript(s string) string {
 	return s
 }
 
-func launchLinuxSession(shell ShellInfo, resumeCmd string, terminal string, cwd string) error {
+func launchLinuxSession(shell ShellInfo, resumeCmd string, terminal string, cwd string, launchStyle string, paneDirection string) error {
+	// Inside WSL, route to Windows Terminal when configured.
+	if terminal == termWindowsTerminal && isWSL() {
+		return launchWSLWindowsTerminal(shell, resumeCmd, cwd, launchStyle, paneDirection)
+	}
+
 	// Supported terminal emulators and their argument patterns.
 	terminals := []struct {
 		name string
@@ -705,6 +717,13 @@ func launchLinuxSession(shell ShellInfo, resumeCmd string, terminal string, cwd
 		}
 	}
 
+	// Auto-detect: try Windows Terminal first if running under WSL.
+	if isWSL() {
+		if _, err := exec.LookPath("wt.exe"); err == nil {
+			return launchWSLWindowsTerminal(shell, resumeCmd, cwd, launchStyle, paneDirection)
+		}
+	}
+
 	// Auto-detect: try terminals in order of popularity.
 	for _, t := range terminals {
 		if p, err := exec.LookPath(t.name); err == nil {
@@ -719,6 +738,76 @@ func launchLinuxSession(shell ShellInfo, resumeCmd string, terminal string, cwd
 	return errors.New("no supported terminal emulator found; tried alacritty, kitty, wezterm, gnome-terminal, konsole, xfce4-terminal, xterm")
 }
 
+// launchWSLWindowsTerminal launches a session via wt.exe from within WSL.
+// It translates the working directory from a Linux path to a Windows path
+// using wslpath and constructs wt.exe arguments for the requested launch
+// style (tab, window, or pane).
+func launchWSLWindowsTerminal(shell ShellInfo, resumeCmd string, cwd string, launchStyle string, paneDirection string) error {
+	p, err := exec.LookPath("wt.exe")
+	if err != nil {
+		return fmt.Errorf("wt.exe not found on PATH: %w", err)
+	}
+
+	// Translate cwd to a Windows path (empty string on failure).
+	var winCwd string
+	if cwd != "" {
+		winCwd, _ = wslToWindowsPath(cwd)
+	}
+
+	distro := os.Getenv("WSL_DISTRO_NAME")
+	args := buildWSLWTArgs(shell, resumeCmd, winCwd, distro, launchStyle, paneDirection)
+
+	cmd := exec.Command(p, args...)
+	return cmd.Start()
+}
+
+// buildWSLWTArgs constructs the wt.exe argument list for launching a WSL
+// session inside Windows Terminal. It is separated from launchWSLWindowsTerminal
+// so it can be tested without requiring wt.exe or a WSL environment.
+func buildWSLWTArgs(shell ShellInfo, resumeCmd, winCwd, distro, launchStyle, paneDirection string) []string {
+	var args []string
+	switch launchStyle {
+	case LaunchStyleWindow:
+		args = append(args, "-w", "new", "new-tab")
+	case LaunchStylePane:
+		args = append(args, "-w", "0", "split-pane")
+		if paneDirection != "" && paneDirection != "auto" {
+			args = append(args, "--direction", paneDirection)
+		}
+	default:
+		args = append(args, "-w", "0", "new-tab")
+	}
+
+	if winCwd != "" {
+		args = append(args, "--startingDirectory", winCwd)
+	}
+
+	// wt.exe wsl.exe -d <distro> -- <shell> -c <resumeCmd>
+	if distro != "" {
+		args = append(args, "wsl.exe", "-d", distro, "--", shell.Path, "-c", resumeCmd)
+	} else {
+		args = append(args, "wsl.exe", "--", shell.Path, "-c", resumeCmd)
+	}
+
+	return args
+}
+
+// wslToWindowsPath translates a Linux filesystem path to a Windows path
+// using the wslpath utility available inside WSL.
+func wslToWindowsPath(linuxPath string) (string, error) {
+	cmd := exec.Command("wslpath", "-w", linuxPath)
+	out, err := cmd.Output()
+	if err != nil {
+		// Include stderr from wslpath for better diagnostics.
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) && len(exitErr.Stderr) > 0 {
+			return "", fmt.Errorf("wslpath: %s: %w", strings.TrimSpace(string(exitErr.Stderr)), err)
+		}
+		return "", fmt.Errorf("wslpath: %w", err)
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
 // ---------------------------------------------------------------------------
 // Terminal detection
 // ---------------------------------------------------------------------------
@@ -758,6 +847,15 @@ func detectDarwinTerminals() []TerminalInfo {
 
 func detectLinuxTerminals() []TerminalInfo {
 	var terms []TerminalInfo
+
+	// Inside WSL, include Windows Terminal when wt.exe is available
+	// via the WSL-Windows interop PATH.
+	if isWSL() {
+		if _, err := exec.LookPath("wt.exe"); err == nil {
+			terms = append(terms, TerminalInfo{Name: termWindowsTerminal})
+		}
+	}
+
 	candidates := []string{
 		"alacritty", "kitty", "wezterm",
 		"gnome-terminal", "konsole", "xfce4-terminal", "xterm",