Category Archives: PowerShell

Are AMD Chipset SW & Drivers Current?

I was reading through TechPowerUp‘s driver news and download threads yesterday when various chipset and device updates caught my eye. That led to the obvious question: what shape are my AMD chipset software and drivers in on my Ryzen 7 5800X desktop? TechPowerUp currently lists AMD Ryzen Chipset Drivers 8.09.28.1124 as the latest package. Time to see what Flo6 actually has. Here’s how I answered the query: Are AMD chipset SW & drivers current?

Checking: Are AMD Chipset SW & Drivers Current?

This is something AMD could make easier. Indeed, Intel offers the Driver & Support Assistant (DSA) for this very purpose. The company describes the tool as a way to identify products, and obtain their latest driver and software updates. On my AMD systems, the only one-stop tool checks the chipset driver itself, not device drivers (see lead-in graphic; note the lack of install date info). So instead, I’ll turn to PowerShell.

That’s not horribly challenging. But it makes me chuckle that checking motherboard plumbing for currency involves some actual detective work.

First: the Installed Chipset Package

I started with the Windows uninstall registry entries. The depicted query checks both normal and WOW6432Node uninstall locations and filters them for AMD chipset entries.

Flo6 reported two registrations, AMD Chipset Software and AMD_Chipset_Drivers. Both showed version 8.09.28.1124. The second also supplied an install date of 20261022, or October 22, 2026. That’s a reassuringly consistent answer rather than two package versions arguing in the registry.

Next: Inventory AMD Drivers

The package version is only half the story. I next queried Win32_PnPSignedDriver and selected entries whose provider matches AMD. Flo6 reported AMD GPIO controllers at 3.0.5.0 and 2.2.0.137, AMD PCI at 1.0.0.90, AMD PSP 11.0 at 5.46.0.0, and AMD SMBUS at 2.0.0.25.

I also ran Get-PnpDevice -PresentOnly and filtered FriendlyName for AMD. Every returned device showed Status OK. That included the PCI, GPIO, USB, PSP, processor and SMBUS entries. A follow-up query for PnP problem codes returned precisely what a troubleshooter likes best: no targets.

Now: Compare to AMD’s Current List

AMD’s release notes identify Ryzen Chipset Driver 8.09.28.1124 as the current package and list support for Ryzen 5000 desktop processors and AM4 chipsets including X570, B550, A520, X470 and B450. The published component table also matches several of Flo6’s installed versions exactly, including PCI 1.0.0.90, GPIO2 2.2.0.137, Windows 11 PT GPIO 3.0.5.0 and PSP 5.46.0.0.

TechPowerUp likewise labels 8.09.28.1124 its latest AMD Ryzen chipset package. In other words, the registry package version wasn’t merely plausible. It lined up with the current published package.

One Version Number Deserves Restraint

Flo6’s SMBUS entry reports 2.0.0.25 while AMD’s package table lists AMD SMBUS Driver 5.12.0.44. I am not treating that discrepancy as a repair invitation. The current AMD package is installed, the hardware reports OK, and there are no PnP problem codes. Those facts provide no evidence that manually forcing a different SMBUS driver onto the machine would improve anything. Consider further that the last AMD chipset updater I ran in August didn’t update that driver, either, and it had the chance to do so.

That’s an important troubleshooting rule: a number that looks different is a reason to investigate, not automatically an update trigger.

Flo6 Gets a Clean Bill of Chipset Health

The checks tell a satisfying story. Flo6 has AMD Chipset Software 8.09.28.1124, installed October 22. Its important AMD chipset devices are present. Their status is OK. No PnP problem codes appear. And the umbrella package matches the current AMD release.

Would I prefer an AMD equivalent to Intel DSA that simply said all of that for me? Absolutely. I enjoy PowerShell, but I don’t believe every driver-status question needs to become a small systems-administration project.

Still, when the convenient button isn’t there, Windows already contains the evidence. A few targeted PowerShell queries expose the package version, individual drivers and device health. Compare those results with AMD’s release notes, and the mystery disappears. Here in Windows-World, there’s ALWAYS another way to get information, if a custom- built tool isn’t available. It just takes a little work…

Facebooklinkedin
Facebooklinkedin

Insider Preview Install Foul-up

I have a pretty high tolerance for Windows Update weirdness. Running Insider Preview builds on multiple machines practically guarantees an occasional hiccup. But there comes a point when repeated troubleshooting stops being persistence and starts looking more like an argument with the update installer.

That is where I landed with the Windows 11 Insider Preview Quality Update for build 26320.10003. On not one but on two PCs, RyzenOfc (AMD B550) and AsusSnap (Snapdragon X1), the update repeatedly marched through the GUI install process. When it reached roughly the 80% neighborhood, it failed. Again. And again.

After enough attempts, repairs, and reboots, the message finally became hard to miss: “It ain’t workin’!” I can only understand this as an Insider Preview install foul-up of some kind. Let me explain…

Why I’m Calling It an Insider Preview Install Foul-up

The first failure on RyzenOfc didn’t worry me much. This is an Insider machine, after all. Updates fail sometimes, particularly preview-quality updates. A second attempt seemed entirely reasonable.

Then AsusSnap failed on the same update. That changed the character of the exercise. RyzenOfc and AsusSnap are different PCs, with very different architectures, yet both were exhibiting essentially the same behavior. Windows Update downloaded the package and began installing it normally. Progress advanced well into the installation, then things fell apart at about 80 percent.

The repeated error history also mattered.I kept seeing the 0x800f0993 error code, over and over. Then I started seeing 0x800f0993. Never even got to the post-GUI install. So I dug into the CBS (Component Based Servicing) log file that tracks the installer at work.

CBS Points at Hydration

Digging into CBS output supplied the useful clue. The failures pointed toward PSFX hydration trouble: Windows servicing could not reconstruct one or more files from the component candidates it saw. In related November 2026 reports, 0x800f0993 appears as PSFX_E_REBASE_HYDRATION_CANDIDATES_MISSING. That’s a more interesting diagnosis than the Windows Update GUI offers.

In my own investigation, four hydration failures stood out in the relevant servicing output. That is the material I wanted front and center in the Windows Terminal graphic for this post. When the same class of servicing failure keeps resurfacing, blindly pressing Retry becomes progressively less compelling and more irritating.

Naturally, I Tried the Usual Repairs

I did not arrive immediately at surrender. Quite the opposite. There were many repeated update attempts. There were restarts. There were component-store checks and repairs. There was the familiar DISM servicing routine, followed where appropriate by System File Checker. Then came another reboot and another visit to Windows Update.

Those are sensible moves when Windows Update trips over damaged local servicing data. They also give me something I value in troubleshooting: evidence. If DISM repairs the component store, SFC comes back clean, the machine restarts normally, and the very same update still falls over in approximately the same place, the odds increasingly favor an update-side servicing problem rather than random local corruption.

That conclusion became still more persuasive because I could reproduce the experience on both RyzenOfc and AsusSnap. Different hardware, same update, same general failure point. Sometimes repetition really is diagnostic data.

When Stuck in a Hole, Time to Stop Digging

There is an old troubleshooting temptation to assume that one more command will crack the case. I am as susceptible as anybody. If DISM did not do it, perhaps clearing update state would. If that isn’t it, perhaps another reboot will. And if that fails, perhaps one more manual inspection of CBS.log will expose some magic line.

Sometimes that instinct pays off. Sometimes it just produces a cleaner machine that still cannot install the update.

That’s where I’m at here. Both PCs continue to operate normally. The failure is repeatable. The servicing logs identify the same general class of problem. Repairs and reboots haven’t changed the outcome. There’s little value in escalating to increasingly invasive repairs merely to force a preview-quality update onto otherwise functional machines. I’m backing off…

Insider Builds Sometimes Require Patience

Build 26320.10003 is a Beta-channel Insider Preview release. That matters. Insider participation is partly about encountering problems before broadly released Windows users do. When two machines hit matching servicing failures, reporting the evidence and waiting for the servicing pipeline to catch up seems a rational next move.

That doesn’t mean I’m ignoring those machines. I’ll keep watching Windows Update, servicing health, and subsequent builds. If Microsoft changes the package or delivers whatever servicing content these systems need, the next attempt may succeed. If the error changes, that’s new data and the investigation starts again.

For Now: It Ain’t Workin’

Troubleshooting is as much about knowing when to stop as knowing what to try. RyzenOfc and AsusSnap gave me the same answer often enough. I listened.

The machines are healthy enough to keep using. DISM and SFC have had their turns. Reboots have been plentiful. Windows Update has received more than a fair number of retries. Yet 26320.10003 keeps stumbling late in the GUI installation phase.

Thus my current technical assessment can be expressed without an HRESULT, a CBS parser, or even PowerShell: It ain’t workin’!

For the moment, that’s okay. Sometimes here in Windows-World, the smartest repair is to quit repairing, document what happened, and give the next update a chance to fix things. In the meantime, I’m standing by…

Facebooklinkedin
Facebooklinkedin

Dueling PowerShell Updates: WU vs. WinGet

Usually, I think of an LTS release as the conservative choice: solid, supported and deliberately behind the leading edge. Thus I had to laugh when Windows Update (WU) brought one PowerShell branch forward, while WinGet immediately pointed to something newer. What looked like a routine update turned into a useful lesson about PowerShell packaging. For a moment, though, it looked very much like a case of dueling PowerShell updates. Cue the banjos!

Why Say Dueling PowerShell Updates?

On the one hand, after WU did its thing, my working PowerShell landed at 7.6.10. That is the shell reached through C:\Program Files\PowerShell\7\pwsh.exe. And indeed, it remains first in the $PATH variable. A quick $PSVersionTable.PSVersion confirmed 7.6.10 was running.

On the other hand, winget list –id Microsoft.PowerShell –exact showed PowerShell 7.6.10 with 7.7.0 available right after that upgrade. PowerShell 7.7 reached GA on November 10, 2026. Microsoft calls it the next Standard Term Support, or STS, release, and it moves PowerShell onto .NET 11. Curiously enough, it too shows a release date of November 10, 2026 at GitHub.

WTF? Two PowerShell updates on the same day, different versions and — as it turns out — different lineages.

When An Upgrade Is More Than That…

Here’s where things get interesting. WinGet did not upgrade my installed 7.6.10 copy. Instead, it reported that the newer version uses a different install technology. Microsoft’s current installation documentation explains the reason. Beginning with PowerShell 7.6, WinGet uses MSIX by default. Beginning with PowerShell 7.7.0, there is no MSI package at all. WinGet installs only MSIX.

I checked the Microsoft Store, but 7.7.0 failed to appear there as an update to my existing installation. WinGet itself supplied a better clue. That is winget show –id Microsoft.PowerShell –exact identified 7.7.0 as an MSIX installer and pointed to the official PowerShell 7.7.0 MSIX bundle on GitHub.

Install Succeeds Where Upgrade Fails

Rather than downloading the bundle manually, I stayed with WinGet. From a normal, non-elevated PowerShell session I ran the user-scoped install shown below. That succeeded. The important distinction is that WinGet could not convert my existing installation in place, but it could install the new MSIX package separately.

winget install --id Microsoft.PowerShell --exact --source winget --scope user

3 Powershells Walk Into a PC…

Afterward, winget list showed three entries: PowerShell 7.7.0, PowerShell 7.6.10 and an older 7.6.9 installation (see lead-in graphic). That sounds messier than it is. Typing pwsh still resolves first to the 7.6.10 executable under Program Files. The 7.7.0 MSIX exposes an application execution alias under my WindowsApps path. So, if I want to run 7.7.0, I must launch it inside 7.6.10 using the PS command string:
& "$env:LOCALAPPDATA\Microsoft\WindowsApps\pwsh.exe".

Here, I’m using the explicit, complete path to the executable to call it directly (that decodes to C:\Users\ed\AppData\Local\Microsoft\
WindowsApps\Microsoft.PowerShell_8wekyb3d8bbwe\pwsh.exe as far as I can tell).

Launching that alias explicitly started PowerShell 7.7.0 inside the same Windows Terminal pane. $PSVersionTable reported 7.7.0, while Get-Process showed the executable running inside the afore-mentioned directory path. In other words, both branches are installed and usable, while 7.6.10 remains my default.

Lessons Learned

The useful lesson is that WinGet can know a newer package exists without being able to upgrade the installation already present. Here, “different install technology” was literal: the path forward crossed from the older installer world into MSIX-only PowerShell 7.7.

For now, keeping 7.6.10 LTS as my default and launching 7.7.0 STS separately provides a usable way to test the new release without disturbing the known-good shell. Sometimes an update failure is not really a failure. Here in Windows-World, this time it’s informing you that the packaging rules for PowerShell have changed. As I mess around with both versions, I’ll get a feel for other changes that might impact my work habits and flow. Stay tuned!

Further Reading

Microsoft Learn, “Install PowerShell 7 on Windows”; PowerShell Team, “Announcing PowerShell 7.7 GA Release” (November 10, 2026).

NeoWin, “PowerShell 7.7 Built on .NET 11 is now generally available” (November 11, 2026).

Microsoft Learn, “What’s New in PowerShell 7.7?” (September 22, 2026).

Facebooklinkedin
Facebooklinkedin

Quick WLAN Profile Cleanup

I’ve known for a long, long time that the netsh wlan show profiles command lists known Wi-Fi networks on suitably equipped Windows PCs. Until now, I’ve periodically used that command to check how many I’ve got and how many I don’t really need. Now, thanks to Copilot’s “script on demand” abilities, I’ve got a script that walks me through the list. It offers a quick WLAN profile cleanup, so I can keep the ones I use, and deep-six the ones I don’t.

PowerShell For Quick WLAN Profile Cleanup

The screencap starts with the list of 7 known wi-fi networks on the Lenovo ThinkPad X380 Yoga. Of the 7 networks shown, I only need 2 of them.

The script (named wifiprofcln.ps1) walks through all known WLAN profiles for Wi-Fi networks, then asks whether to keep or delete each one. As you can see in the screencap, I deleted 5 and kept 2 of the 7 I started out with. Some were from hotels, others from offices, others from my cellphone provider’s hotspot network.

The Real Beauty of On-Demand Scripting

This is just a simple bit of throwaway PowerShell. The script is 40 lines long. It took Copilot less time to build it than it took me to tell it what I wanted the script to do. At one time, I would’ve been inclined to deliver this info as a recipe with the proper way to structure commands and let readers DIY their way through it. Now, I can put together and share a quickie one-off tool in minutes.

Say what you want about the evils of AI, the perils of hallucination or misalignment, or even existential threats. This kind of simple, straightforward use is easy, fast and pretty darn useful. Within scope and with a tight focus, it’s a complete boon to getting things done here in Windows-World. Use it carefully, to be sure, but use it you must!

Facebooklinkedin
Facebooklinkedin

More Discord Follies: Unactivated Download

Sometimes an update problem gets more interesting after the obvious fix succeeds. That just happened to me with Discord on Windows. WinGet insisted version 1.0.9267 was available, while my PC remained on 1.0.9266. Even stranger, forcing the upgrade did not change the reported installed version.

I tried WinGet, UniGetUI and Discord’s in-app updater. Nothing moved the needle. Eventually I performed a clean uninstall and reinstall. That exercise exposed what was really happening: version 1.0.9267 had downloaded, but Discord was still running 1.0.9266. That’s how I found myself engaged in more Discord Follies: unactivated download is present, but inert. WTF?

Unpacking More Discord Follies: Unactivated Download

The basic inventory command showed the mismatch clearly:
winget list --id Discord.Discord --exact --scope user

It reported 1.0.9266 installed and 1.0.9267 available. Discord was installed at user scope, which also produced an instructive side trip. An elevated WinGet session refused to uninstall the per-user package. Switching to a normal Windows Terminal session fixed that.

winget uninstall --id Discord.Discord --exact --scope user

After the uninstall succeeded, I checked for leftovers:

Test-Path "$env:APPDATA\Discord"
Test-Path "$env:LOCALAPPDATA\Discord"

Both returned True. With no Discord processes still running, I removed those directories and verified that both paths returned False. That gave me the clean slate I wanted.

The Clean Install Surprise!

Next came an explicit installation of the supposedly newer release:

winget install --id Discord.Discord --exact --version 1.0.9267 --scope user

WinGet found 1.0.9267, verified its installer hash and reported a successful installation. Yet another winget list still showed 1.0.9266 installed, with 1.0.9267 available. At first glance, that looked impossible.

The file system told a better story. I enumerated Discord’s version directories:

Get-ChildItem "$env:LOCALAPPDATA\Discord" -Directory -Filter "app-*" | Select-Object Name, FullName

There were two of them: app-1.0.9266 and app-1.0.9267. Checking the Discord.exe files confirmed that each directory contained the version its name advertised. Again: WTF?

Installed Is Not Activated, Apparently

The decisive check was to examine the running processes instead of trusting package inventory alone:

Get-Process Discord | Select-Object Id, Path,
@{N='FileVersion';E={$_.MainModule.FileVersionInfo.FileVersion}}

Every running Discord process came from app-1.0.9266. I then checked the per-user uninstall registration:

Get-ItemProperty HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\* |
Where-Object DisplayName -eq 'Discord' |
Select-Object DisplayName, DisplayVersion, InstallLocation, UninstallString

Windows likewise registered Discord as version 1.0.9266. In other words, WinGet was not hallucinating. Version 1.0.9267 really existed on disk, but 1.0.9266 remained the registered and active release.

The Nub of This Discord Folly Is…

Discord’s current generic stable update manifest identifies 1.0.9267 as the host version. I also found installation-specific manifest results that still identify 1.0.9266. That makes staged update selection a plausible explanation for this split state, though the local evidence alone doesn’t completely illuminate  Discord’s rollout policy.

Here, the important lesson is more general. When an updater says success but inventory disagrees, inspect three layers: package registration, files on disk and the executable that’s actually running. Those views might disagree: here they did so spectacularly.

For now, I’m leaving both Discord directories alone. Manually deleting the active release or rewriting its registration would create more, not less

Discord’s current generic stable update manifest identifies 1.0.9267 as the host version. We also found installation-specific manifest results that still identify 1.0.9266. That makes staged update selection a plausible explanation for the split state, although the local evidence alone cannot prove Discord’s rollout policy.

The important lesson is more general. When an updater says success but inventory disagrees, inspect three layers: package registration, files on disk and the executable actually running. Those views can disagree, and here they did spectacularly.

For now, I am leaving both Discord directories alone. Manually deleting the active release or rewriting its registration would create more, not less uncertainty. Here in Windows-World, sometimes the best troubleshooting means knowing exactly why you should stop troubleshooting. I’m done for now, and will wait to see what Discord does next. Sigh.

Further Reading

Discord stable Windows x64 update manifest

Discord Support, Windows Corrupt Installation

Facebooklinkedin
Facebooklinkedin

Checking Hotfix Can Beat Package Check

After reading about KB5127936 and its Cloud Rebuild facility recently, I wondered how many of my production level PCs already sported this Preview CU. So I asked Copilot to craft me some PowerShell to check. Along the way, I learned that: (a) some methods are better than others, and (b) that there are many ways to request such information. It’s also how I learned that checking hofix can beat package check info, depending on what you need.

My first query looked perfectly reasonable:
Get-WindowsPackage -Online | Where-Object PackageName -match '5127936'
Alas, that request returned no output. Such a result could tempt an administrator to conclude that the update was absent. Here, that conclusion would be wrong.

Why Checking Hofix Can Beat Package Check

Turns out the afore-cited PowerShell command (which uses DISM under the hood) assumes that the string  “KB5127936” appears in the package metadata. It does not, as it turns out.

However, this simpler command
Get-HotFix -Id KB5127936
produces a direct hit. You can see the outcomes of both commands in the lead-in screencap. After Get-Hotfix, P16 reported KB5127936 as Update, installed by NT AUTHORITY\SYSTEM on October 29, 2026. For the question I was asking, that was exactly the information I needed.

Why the difference? Microsoft documents Get-HotFix as a cmdlet for retrieving installed hotfixes. It uses  Win32_QuickFixEngineering WMI class, whose -Id parameter accepts a hotfix ID. Microsoft even provides an example specifically for verifying whether an update is installed.

In other words, if I start with a KB number, Get-HotFix gives me a KB-oriented lookup. Good stuff!

Get-WindowsPackage Asks Something Different

Get-WindowsPackage is not broken, nor did DISM somehow miss the operating system update. Microsoft describes this cmdlet as a way to obtain information about packages in a Windows image. With -Online, that targets the running Windows installation.

The distinction matters because PackageName is the name of a servicing package inside the image. It is not promised to be the public KB identifier with which its labeled. Microsoft also notes that Get-WindowsPackage cannot provide detailed package information for .msu files, only .cab files. And KB5127936 arrives in .msu form.

Thus my pipeline was really asking, “Does any returned package name contain the characters 5127936?” The empty result answered that narrow question. It did not establish that KB5127936 was missing. And that’s because the package data omits that string. Sigh.

Match the Cmdlet to the Question

This suggests a useful rule of thumb. When somebody hands you a KB number and asks whether that update is installed, try Get-HotFix first:  Get-HotFix -Id KB5127936

For scripts, I like a quiet Boolean-style test:
if (Get-HotFix -Id KB5127936 -ErrorAction SilentlyContinue) { 'INSTALLED' } else { 'NOT FOUND BY GET-HOTFIX' }
That wording is deliberately cautious. Get-HotFix is not a universal inventory of everything Windows Update has ever installed, either. Microsoft defines its scope through QuickFixEngineering. Absence from that view should trigger another check, not a final verdict.

Package Checks Retain Their Value

When I am servicing an online or mounted Windows image, inspecting package identities, or working with CAB-based packages, Get-WindowsPackage remains the right tool. It answers a package-servicing question rather than a KB-history question.

That P16 session reinforced an old Windows lesson: command output only makes sense in the context of the question asked. Here, Get-WindowsPackage told me there was no package name matching my KB string. Get-HotFix told me the update associated with that KB was installed.

Sometimes the simpler check really is the better check. On P16, it certainly was. Here in Windows-World simple is not only faster and easier; it’s a minor but useful labor-saving device!

Further Reading

Microsoft Learn: Get-HotFix (Microsoft.PowerShell.Management)

Microsoft Learn: Get-WindowsPackage (Dism)

Facebooklinkedin
Facebooklinkedin

Scripting Macrium Rescue Disk Repair

Here’s something I’ve been chewing on for the past few weeks. I’ve had help from a persistent and curiously passive interlocutor at ElevenForum.com. I still use Macrium Reflect to back up at least half of my PC fleet.

For whatever reason, the Macrium Software team has yet to update its Rescue Disk creation to accommodate Secure Boot requirements. That’s what led me to scripting Macrium Rescue Disk repair using Copilot and PowerShell. Therein hangs today’s post…

What’s Involved in Scripting Macrium Rescue Disk Repair?

Basically, I asked Copilot to build a PowerShell script to fix the Macrium Rescue Disk for Secure Boot. Why? I use Secure Boot on all my PCs.

I can’t restore a Reflect boot image unless the Rescue Disk will actually BOOT the target PC. Only then can I perform the restore operation.

For the record, I’m using Macrium Reflect X, not the older versions numbered 8.x or lower. Working with Copilot, I had to chunk through three, then four versions before the script worked on my PC.

That PC is Flo6, my B550-based desktop. It has an MSI MAG Tomahawk MAX motherboard, Ryzen 7 5800X, NVIDIA RTX 3070 Ti, and 64GB RAM.

Using Copilot Requires LOTS of Trial and Error

The output from the script itself documents what it does pretty well, so I reproduce it here:

==============================================================
  fixmrrdv6.ps1  --  Secure Boot SVN Repair Tool              
==============================================================
   [>>] Validating target drive: G:                                                                                                                       
       [OK] Drive label  : ESD-USB                                                                                                                       
       [OK] File system  : FAT32
       [OK] Size         : 14.4 GB
       [!!] Label 'ESD-USB' does not contain MACRIUM -- verify correct drive.
   [>>] Locating boot.wim on rescue media                                                                                                                 
       [OK] Found WIM    : G:\sources\boot.wim                                                                                                           
       [OK] WIM size     : 557.2 MB
   [>>] Locating Secure Boot source files from live Windows
       [OK] External source: C:\Windows\Boot\EFI_EX\bootmgfw_EX.efi
       [OK] WIM source     : C:\Windows\Boot\EFI_EX\bootmgfw_EX.efi
       [OK] Winload source : C:\Windows\System32\winload.efi
       [OK] Backup root    : C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946
   [>>] Replacing external bootmgfw.efi on USB
       [OK] Backed up: bootmgfw.efi -> C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946\ExternalUSB\bootmgfw.efi
       [OK] Replaced: bootmgfw.efi from EFI_EX\bootmgfw_EX.efi
   [>>] Patching boot.wim (index 1) with Secure Boot files
       [OK] Mount directory  : C:\Users\ed\AppData\Local\Temp\FixMRRD_WimMount_20261026155946
       [!!] Mounting WIM (this may take a minute)...
       [OK] WIM mounted successfully.
       [OK] Backed up: bootmgfw.efi -> C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946\WIM\bootmgfw.efi
       [OK] Patched: bootmgfw.efi
       [OK] Backed up: bootmgfw_EX.efi -> C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946\WIM\bootmgfw_EX.efi
       [OK] Patched: bootmgfw_EX.efi
       [OK] Backed up: winload.efi -> C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946\WIM\winload.efi
       [OK] Patched: winload.efi
       [!!] Committing and unmounting WIM (this may take a minute)...
       [OK] boot.wim patched and committed successfully.

==============================================================
  All done! Secure Boot SVN repair completed successfully.
  Run check_bootmedia.ps1 against the USB to verify ALLOWED.
==============================================================

To debug this script, I kept catching error messages as it ran, reporting them to Copilot, and re-running rewritten versions until it produced a clean Rescue Disk on Flo6. How did I define that? By running Garlin’s check_bootmedia.ps1 script against it until it returned a clean result (all boot managers use CA 2023, show up as ALLOWED, use SVN 12.0). And indeed it works on Flo6 right now just fine.

What Works for Me, May Not Work for YOU

What I’ve learned from my interlocutor on ElevenForum.com is the following. Though the script runs on Flo6, it doesn’t run on his PC. Based on the errors he’s reporting, I think I know what’s going on. Writing files into a mounted WIM is tricky, as I’ve learned, and requires extensive mucking about with permissions. System ownership must be taken over, writing work done, then restored to pristine condition. This takes work and some understanding of how ACLs and the Trusted Installer work in modern Windows OSes (10 and 11, basically, though the same behaviors also hold in current Windows Server versions).

When things go wrong for me with a script like this one, I attack them with Copilot until they work. My interlocutor, apparently, isn’t inclined to do this himself. But that’s what it takes to make things work on YOUR PC here in Windows-World: a dogged determination to keep iterating until the error messages no longer appear, and the resulting functionality does what you want it to do.

Post some comments here to let me know if you’re OK with this “exercise is left to the reader to fully complete” approach. Those who really want the script to fix their Macrium Reflect X Rescue Disks can ask for it, and I’ll send it to them. But they’ll have to be ready to make it work on their PCs to achieve its intended use!

Facebooklinkedin
Facebooklinkedin

MediaMonkey Version Info Fools WinGet

MediaMonkey recently taught me another lesson about package managers: version information has to agree at both ends. Otherwise, automation can outstrip itself. Indeed, I’ve just witnessed how truncated MediaMonkey version info fools winget into a looping update.

I had already run a broad WinGet update using winget upgrade –all –include-unknown. MediaMonkey was included and its update completed successfully. Later, though, WinGet proffered MediaMonkey again. That follow-on install also completed successfully, leaving me wondering why an already updated application looked stale.

How Truncated MediaMonkey Version Info Fools WinGet

The lead-in screenshot makes a mismatch plain. WinGet identifies the package as VentisMedia.MediaMonkey.2024. Its list output reports the installed Version as “2024,” but Available is “2024.2.2.3222.” From WinGet’s perspective, those strings do not match.

A PowerShell registry query settles the question from the installed-software side. MediaMonkey 2024 records DisplayVersion simply as “2024.” The same entry identifies Ventis Media Inc. as Publisher and points to the 32-bit Program Files installation location.

Get-ItemProperty `
HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*,
HKLM:\Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*, `
HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\* `
-ErrorAction SilentlyContinue | `
Where-Object DisplayName -Like '*MediaMonkey*' | `
Select-Object DisplayName, DisplayVersion, Publisher, InstallLocation, PSPath

That is the crux of the problem. The installed application advertises “2024.” The WinGet package advertises “2024.2.2.3222.” Thus, WinGet continues to find the need to upgrade even after installing the latest package.

A Blocking Pin Breaks the Loop

Rather than let routine upgrade runs keep revisiting MediaMonkey, I added a blocking pin against the package ID:

winget pin add --id VentisMedia.MediaMonkey.2024 --blocking

The next winget pin list confirms the result. MediaMonkey 2024 appears with version 2024, source winget, and pin type Blocking.

That choice is deliberately stronger than an ordinary pin. Microsoft documents a blocking pin as preventing upgrades through both “winget upgrade –all” and a direct package upgrade. The package must be unpinned before a normal WinGet upgrade can proceed, although the force option can override this specific pin behavior.

Watch, Wait, Then Unpin When It’s Time

For now, blocking is exactly what I want. The installed MediaMonkey is current based on the package I just installed, while its reported version remains too broad and unspecific for WinGet to compare cleanly.

The next move is patience. I will periodically check MediaMonkey and the WinGet package metadata. When a genuine new release appears, I can remove the block, run the upgrade, and see whether the installed DisplayVersion finally reports a fully qualified build number.

If that happens, WinGet should again have comparable version strings to work with. If not, the blocking pin can go right back on.

Version Metadata Makes the Difference

Yesterday’s episode is a useful reminder that WinGet can only act on available version information. A successful install does not guarantee the application and package catalog describe the result identically.

Here, two command-line checks tell the whole story. First, winget list exposes the disagreement. Second, PowerShell confirms what Windows knows about MediaMonkey. Until those values line up, a blocking pin turns an annoying repeat upgrade into a controlled watch-and-wait problem. Case closed, at least for now. Here in Windows-World it’s been added to the list of things I must watch and remember. It’s a big and pretty active one, as Windows pros already know…

Facebooklinkedin
Facebooklinkedin

Powershell Update Goes Sideways

Interesting doings in the Windows Terminal PowerShell world. Running WinGet in that environment just now, I updated PS. Not only did that activity produce an “Installation abandoned” error msg, it initially threw up cmd prompt instead of PS when I clicked the plus sign to launch a new WinTerm session. Alas, it looks like this PowerShell update goes sideways (and more so on some PCs).

Ways PowerShell Update Goes Sideways

First, let’s survey the landscape. Windows PowerShell 5.1 is built into Windows and goes nowhere. It is a system component, not something you update through a package manager. PowerShell 7.x is a completely separate, side-by-side install. It lives in its own directory and uses its own executable, pwsh.exe.

The standard command for updating PowerShell 7.x is clean and simple. You open a terminal and run winget upgrade --id Microsoft.PowerShell. However, what looks simple on the surface can hide a lot of failure modes underneath.

Updates can stall mid-stream, roll back without a clear explanation, or appear to succeed while doing nothing at all. That last scenario is especially maddening. You see a success message, then run pwsh --version and get the old build number staring back at you. Something broke during the install, and winget did not catch it.

Oh No! Installation Abandoned…

I’ve seen this error message (see lead-in graphic) before. Normally, that means the PS installer has lost its connection to Winget via PowerShell and WinTerm. You can often see the PS installer window open, still running, and finishing its work. Closing, then re-opening WinTerm usually sets things back to rights.

Not this morning, on my Flo6 desktop (B550 mobo with AMD Ryzen 7 5800X CPU). After the upgrade, a new PS session launched cmd prompt instead. WinTerm lost its path to the pwsh.exe executable. When I went to look at its profile, it showed as empty. So I had to delete it, and recreate it, then point to the PowerShell 7 icon. That fixed things right up.

That Worst Case Isn’t Ubiquitous

When I updated PS on the Lenovo ThinkPad P16 Gen 1 mobile workstation, I got the same “installation abandoned” error message. But when I opened a new PS session (using the menu bar “+” control) the new version popped right up in a proper PowerShell pane.

I’m not sure why some machines act out more than others when the PS install goes sideways. Shoot! It could have been cosmic rays. But whatever happens, you can fix it if you check the profile and make sure it’s properly defined. Here in Windows-World knowing what to fix and how to fix it goes a long, long way. This morning, it went far enough to set things back up properly on Flo6. May it do the same for you, should you need it to!

One More Thing…

Just ran the same update on the ASUS Zenbook A14 (Snapdragon X ARM CPU). Completed successfully! I’m starting to think that platform diffs may play into this situation. The AMD platform failed and carried a persistent error state. The Intel platform failed, but recovered. And the ARM platform sailed right thru. Go figure!

 

Facebooklinkedin
Facebooklinkedin

Fixing Macrium Rescue Disk

Microsoft updated its Secure Boot revocation database (DBX) in mid-2026. That update requires Boot Manager binaries to carry a minimum Security Version Number (SVN) of 11.0. It also bans the older “Production PCA 2011” signing certificate. Rescue media that Macrium Reflect X builds fails both tests out of the box. That means with Secure Boot enabled, the Reflect’s boot media won’t work. That’s why I’m writing today about what’s involved in fixing Macrium Rescue Disk.

Most important, this post walks you through a PowerShell script named fixmrrd.ps1 that fixes all three BANNED files in a single pass. Buckle up! There’s LOTS of ground to cover…

Why Fixing Macrium Rescue Disk Is Necessary

Macrium Reflect X builds its WinPE rescue environment from the Windows ADK (Assessment and Deployment Kit). The ADK ships once per Windows release and never gets Patch Tuesday updates. Its boot files stay frozen at the SVN level they carried on release day.

For Windows 11 24H2, the WADK 11 ADK shipped with boot files at SVN 2.0. The current DBX floor is SVN 11.0. That nine-version gap is the core problem that requires fixing.

The standard boot manager file, aka bootmgfw.efi that lives under C:\Windows\Boot\EFI\ also carries the banned Production PCA 2011 certificate. Even when the SVN is correct, that certificate triggers a hard BANNED result. Garlin’s check_bootMedia.ps1 diagnostic tool makes both problems visible immediately.

Introducing fixmrrdv2.ps1

fixmrrdv2.ps1 bridges the gap Macrium leaves open. It pulls every replacement file from your live, fully patched Windows 11 installation. Those files already meet the SVN 11.0 requirement and carry the correct Windows UEFI CA 2023 certificate. It’s a v2 version because @Monica1491 over at ElevenForums pointed out an error that I fixed.

Here is what the script does at each step:

  1. Validates the target USB drive and confirms it carries a MACRIUM label.
  2. Locates boot.wim on the rescue media, typically at sources\boot.wim.
  3. Identifies three source files from your live Windows installation: bootmgfw.efi, bootmgfw_EX.efi, and winload.efi. It reports the version number of each file.
  4. Replaces the external bootmgfw.efi on the USB EFI partition. It uses the EX variant (bootmgfw_EX.efi) as the source — not the standard bootmgfw.efi. The standard file carries the banned Production PCA 2011 certificate. The EX variant carries the required Windows UEFI CA 2023 certificate.
  5. Mounts boot.wim using DISM. Then it adjusts ACLs on the internal target files. WIM images lock their contents with restrictive ACLs. Even Administrator hits an access-denied error without a takeown and icacls step first.
  6. Replaces bootmgfw_EX.efi and winload.efi inside the mounted WIM.
  7. Commits the changes and unmounts the WIM. If any step fails, DISM discards the mount and leaves the original WIM intact.

The script backs up every replaced file with a timestamped .bak_ suffix before touching it. Color-coded [OK], [!!], and [FAIL] status lines show progress at each step.

Before You Run the Script…

There are four prerequisites apply before you run fixmrrdv2.ps1.

  • Run as Administrator. DISM mount operations require elevation.
  • Use Windows PowerShell 5.1 (powershell.exe). Do NOT use PowerShell 7.x (pwsh.exe). The DISM /Mount-Image command does not work correctly under PowerShell Core. The script detects PS 7.x automatically and exits with a clear message if you start it from the wrong shell.
  • Your Macrium rescue USB must be plugged in and assigned a drive letter. Note that letter before you start.
  • Your execution policy must allow local scripts. Run this in an elevated PS 5.1 window if needed:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Download fixmrrdv2.txt from its OneDrive link (read only). Rename it to fixmrrd.ps1. Place it in a convenient location, such as C:\tools\scripts\.

Running the Script…

Open an elevated Windows PowerShell 5.1 window. Navigate to the folder holding fixmrrd.ps1. Then run:

.\fixmrrd.ps1 -TargetDrive G:

Substitute your actual rescue drive letter for G:. If you omit -TargetDrive, the script prompts you for it.

The script runs without further interaction. The DISM commit step takes the longest — typically 30 to 60 seconds. Do not interrupt that step.

Each replaced file gets a timestamped .bak_ backup before the script writes anything new. You can restore any original file by renaming the matching backup.

One timing note: the script reports source file versions from C:\Windows\Boot\EFI\ and C:\Windows\Boot\EFI_EX\. You may notice the version number on the USB after copy differs slightly from what the script reported. This is a FAT32 metadata quirk. The SVN level is what really matters, and transfers correctly.

Verifying Results

Run Garlin’s check_bootMedia.ps1 against the drive when the script finishes:

.\check_bootMedia.ps1 G: -audit -verbose

A correctly fixed drive shows all three boot files as ALLOWED:

USB Drive g: "MACRIUM_PE"
    Windows Boot Manager [Windows UEFI CA 2023] is ALLOWED.
        g:\EFI\Microsoft\Boot\bootmgfw.efi
        File Version: 28000.367, SVN 11.0

    boot.wim:1 (WinPE 26100.1)
        Boot Manager [Windows UEFI CA 2023] is ALLOWED.
            \Windows\Boot\EFI_EX\bootmgfw_EX.efi
            File version: 28000.367, SVN 11.0

    \Windows\System32\winload.efi is ALLOWED.
        File version: 26100.9444

If any file still shows BANNED, check that you ran the script in PowerShell 5.1 with elevation. Re-run if needed — the backup files let you roll back safely.

The Net-Net: Working Rescue Disk

This is a product gap in Macrium Reflect X, not a user error. Macrium builds from ADK components that Microsoft does not update through Patch Tuesday. The recoverydrive.exe tool that ships with Windows sources its boot files directly from the live OS. Macrium does not. Until Macrium ships a fix that closes that gap, fixmrrd.ps1 fills it. It ticks me off, and that’s why I decided to script my way around it.

Keep this script on hand. The next time you rebuild a Macrium rescue drive, perhaps after a major Windows update or a new ADK release, you will need it again. The whole process takes under two minutes once you know the steps. Here in Windows-World, when vendors don’t fix their stuff, we users must sometimes step in to help out. Cheers!


Facebooklinkedin
Facebooklinkedin