Firstly, I am standing on the shoulders of giants.  As the comments below state, the essential first function, Set-WindowState, is only slightly modified from the original form at

http://www.snip2code.com/Snippet/50118/Hide--Show--Minimize--Maximize--etc-wind/

Specifically, it now tests the current PID’s ParentProcessID.  Much hair-pulling has shown that these calls only work if the PowerShell window is the one started from either a shortcut, the Start menu/screen, or Win+R.  If the current PowerShell process is the child process of another shell, be it PowerShell or cmd.exe, then the calls to Set-WindowState fail silently.

####################
function Set-WindowState
####################
{
    <#
    .SYNOPSIS 
    Show, Hide Minimize, Maximize, or Restore the Powershell Console or other Window. 
        
    .DESCRIPTION 
    Show, Hide Minimize, Maximize, or Restore the Powershell Console or other Window. 

    Very slightly modified form of 
    http://www.snip2code.com/Snippet/50118/Hide--Show--Minimize--Maximize--etc-wind/
            
    .PARAMETER WindowState
    [string] The New Window state Mode.
        May be one of the following:
                        
            Hide                Hides the window and activates another window.
            Normal              Activates and displays a window. This is the Default. If the window is minimized or maximized, the system restores it to its original size and position. An application should specify this flag when displaying the window for the first time.
            ShowMinimized       Activates the window and displays it as a minimized window.
            Maximize            Maximizes the specified window.
            ShowNoActivate      Displays a window in its most recent size and position. This value is similar to SW_SHOWNORMAL, except that the window is not activated.
            Show                Activates the window and displays it in its current size and position. 
            Minimize            Minimizes the specified window and activates the next top-level window in the Z order.
            ShowMinNoActive     Displays the window as a minimized window. This value is similar to SW_SHOWMINIMIZED, except the window is not activated.
            ShowNA              Displays the window in its current size and position. This value is similar to SW_SHOW, except that the window is not activated. 
            Restore             Activates and displays the window. If the window is minimized or maximized, the system restores it to its original size and position. An application should specify this flag when restoring a minimized window.
            ShowDefault         Sets the show state based on the SW_ value specified in the STARTUPINFO structure passed to the CreateProcess function by the program that started the application. 
            ForceMinimize       Minimizes a window, even if the thread that owns the window is not responding. This flag should only be used when minimizing windows from a different thread.

    .PARAMETER ID
    [Int] The Process Identifier (PID) of the Target Window. If this parameter is not specified the Target window defaults to the current Powershell Console Window.

    .INPUTS
    [Int] $ID You can pipe Process Identifier (PID) of the Target Window.

    .OUTPUTS
    Returns $false if run in a subshell, returns $null otherwise.

    .Example
    PS C:\Users\User\Documents> Set-WindowState -WindowState Minimize

    This will Minimize the Powershell Console Window.

    .Link
    http://www.snip2code.com/Snippet/50118/Hide--Show--Minimize--Maximize--etc-wind/

    .notes
    This only works in the original PSH window spawned off explorer.exe.  It does not work in subshell, where PSH (or cmd.exe) calls PowerShell.exe.

    #>

    param (  
        [parameter(
            Mandatory=$false, 
            ValuefromPipeline = $false
        )] 
        [String] [ValidateSet( 
            "Hide", 
            "Normal", 
            "ShowMinimized", 
            "Maximize", 
            "ShowNoActivate", 
            "Show", 
            "Minimize", 
            "ShowMinNoActive", 
            "ShowNA", 
            "Restore", 
            "ShowDefault", 
            "ForceMinimize"
        )] $WindowState = "Normal",
            
        [parameter(
            Mandatory=$false, 
            ValuefromPipeline=$true,
            ValueFromPipeLineByPropertyName=$true
        )]  
        [Int] $ID = $PID
    );

    #region check if we are a subshell or not.  If we're a subshell, this won't work.

    $parentProcessId = (
        Get-WmiObject -Query "SELECT ParentProcessId FROM Win32_Process WHERE ProcessId=$PID"
    ).ParentProcessId;

    if ((Get-Process -Id $parentProcessId).ProcessName -ne 'explorer')
    {
            $message = "$($MyInvocation.MyCommand.Name) can only be run in a PowerShell window started from explorer.  It cannot control windows when it is running in a subshell.  Stopping.";
            Write-Error -ErrorAction SilentlyContinue -Message $message;
            Write-Warning -Message $message;
            return $false;
            break __outOfScript;

    } # if ((Get-Process -Id $parentProcessId).ProcessName -ne 'explorer')

    #endregion
    #region set up the magic here

    # this really should be an [Enum]
    $windowStateHash = @{
        Hide             =  0;
        Normal           =  1;
        ShowMinimized    =  2;
        Maximize         =  3;
        ShowNoActivate   =  4;
        Show             =  5;
        Minimize         =  6;
        ShowMinNoActive  =  7;
        ShowNA           =  8;
        Restore          =  9;
        ShowDefault      = 10;
        ForceMinimize    = 11;
    };

    $showWindowAsync = Add-Type -MemberDefinition '
        [DllImport("user32.dll")] 
        public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
    ' -Name "Win32ShowWindowAsync" -Namespace Win32Functions -PassThru;

    #endregion

    # pull off the magic
    $showWindowAsync::ShowWindowAsync((Get-Process -id $ID).MainWindowHandle, $windowStateHash.$WindowState) | Out-Null;
    
} # function Set-WindowState


####################
function Send-Keys
####################
{
    <#
    .Synopsis
    Send keystrokes to another window.

    .Description
    A really brittle PSH implementation of the beloved and oft-abused SendKeys.SendWait().  
    
    If a window title is specified AND UNIQUE (i.e. there cannot be another window with the same title), then that window is given focus.

    If a window title is not specified, the current PowerShell window will be minimized and whichever window previously had focus will be given focus.

    Keystrokes are sent one-at-a-time, with a set delay between each.

    .Parameter InputString
    [string[]] Data to be sent.

    .parameter WindowTitle
    Title of window to be sent keystrokes.  Must be unique of all windows on dekstop, opened or minimized.

    .parameter Milliseconds
    Delay between keystrokes. Default is 100ms (1/10 of a second).  Note that the application that received incoming keystrokes may buffer them, so this only specifies the MAXIMUM keystrokes that can be sent per second.

    .parameter NoActivate
    Default behaviour is to restore the PowerShell window and give it focus.  This leaves focus with the application that received the incoming keystrokes.

    .link
    Send-Keys (gc .\_vimrc) -WindowTitle 'Windows PowerShell ISE'

    #>

    param ( 
        [parameter(ValueFromPipeline=$true)][string[]]$InputString = @(),
        [string]$WindowTitle = $null,
        [int]$Milliseconds = 100,
        [switch]$NoActivate
    );

    begin
    {

        #region check if we are a subshell or not.  If we're a subshell, this won't work.

        $parentProcessId = (
            Get-WmiObject -Query "SELECT ParentProcessId FROM Win32_Process WHERE ProcessId=$PID"
        ).ParentProcessId;

        if ((Get-Process -Id $parentProcessId).ProcessName -ne 'explorer')
        {
                $message = "$($MyInvocation.MyCommand.Name) can only be run in a PowerShell window started from explorer.  It cannot control windows started in a subshell.  Stopping.";
                Write-Error -ErrorAction SilentlyContinue -Message $message;
                Write-Warning -Message $message;
                return $false;
                break __outOfScript;

        } # if ((Get-Process -Id $parentProcessId).ProcessName -ne 'explorer')

        #endregion
        #region determine which window to target (specified one, or one with last focus)

        if ($WindowTitle)
        {
            $windowHandles = Get-Process | 
                ? { $_.MainWindowTitle -eq "$WindowTitle"} |
                Select-Object -ExpandProperty MainWindowHandle;

            if (!$windowHandles)
            {
                $message = "$($MyInvocation.MyCommand.Name) -WindowTitle '$WindowTitle' not found.  Stopping.";
                Write-Error -ErrorAction SilentlyContinue -Message $message;
                Write-Warning -Message $message;
                return $false;
                break __outOfScript;
            
            } # (if !$windowHandles)
            elseif ($windowHandles.Count -gt 2)
            {
                $message = "$($MyInvocation.MyCommand.Name) -WindowTitle '$WindowTitle' found $($windowHandles.Count) windows, expected to find only 1.  Stopping.";
                Write-Error -ErrorAction SilentlyContinue -Message $message;
                Write-Warning -Message $message;
                return $false;
                break __outOfScript;

            } # if (!$WindowsHandles) ... elseif

             Add-Type '
                using System;
                using System.Runtime.InteropServices;
                public class WindowControl {
                    [DllImport("user32.dll")]
                    [return: MarshalAs(UnmanagedType.Bool)]
                    public static extern bool SetForegroundWindow(IntPtr hWnd);
                }
            ';
            
            [WindowControl]::SetForegroundWindow(($windowHandles | Select-Object -First 1));

        } # if ($WindowTitle)
        else
        {
            Set-WindowState -ID $PID -WindowState Minimize;

        } # if ($WindowTitle) ... else

        #endregion
        #region other initializations

        #save the window size, because restoring focus may reset it
        $windowSize = $Host.UI.RawUI.WindowSize

        # counter for number of characters sent;
        $i = 0;

        [void] [System.Reflection.Assembly]::LoadWithPartialName("'System.Windows.Forms");

        #endregion

    } # begin

    process {
        
        foreach ($line in $InputString)
        {
            foreach ($char in [char[]]$line)
            {
                if ($char -match "[\+\^\%\~\(\)\{\}\[\]]")
                {
                    [string]$char = "{$char}";

                } # if ($char -match "...

                [System.Windows.Forms.SendKeys]::SendWait($char);
                Start-Sleep -Milliseconds $Milliseconds;
                $i += 1;
                
            } # foreach ($char in [char[]]$line)
            
            [System.Windows.Forms.SendKeys]::SendWait("{ENTER}");
            $i += 1;

        } # foreach ($line in $InputString)

    } # process

    end
    {

        if (!$NoActivate)
        { # if -NoActivate specified, don't reopen the PSH window

            # otherwise, set it back as it ever was.
            Set-WindowState -ID $PID -WindowState Restore;
            $Host.UI.RawUI.WindowSize = $windowSize;

        } # if (!$NoActivate)

        return $i;

    } #end

} # function Send-Keys