Category Archives: Cool Tools

Winget Acrobat Update Oddities

I like WinGet. Really, I do. Few Windows conveniences beat opening PowerShell, typing a command, and watching a fistful of applications march toward newer versions without visiting six websites and clicking through a small mountain of installers. When it works that way, WinGet feels almost civilized. Then there is Adobe, from which company I’ve recently experience WinGet Acrobat update oddities.

Indeed, my latest Acrobat update reminded me that package managers can standardize the command you type without standardizing what happens afterward. That distinction seems academic right up until an update turns into an obstacle course.

What Are Winget Acrobat Update Oddities?

I started with WinGet because Acrobat showed an available update. Fair enough. Instead of letting Acrobat update itself, I figured I would let the Windows Package Manager handle the job along with the rest of normal maintenance. One command, one update, one happy administrator. What could possibly go wrong?

The first interruption was Outlook. The Adobe installer wanted it closed. That’s not particularly shocking. Acrobat’s integrations  touch other applications, and installers sometimes need cooperating software out of the way. I closed Outlook and carried on.

Then Adobe wanted File Explorer and Everything closed as well. This is where my eyebrows started heading north.

Closing Explorer Apparently Isn’t Closing Explorer

I dutifully closed File Explorer. Adobe remained unimpressed. The installer wasn’t asking whether an Explorer window was visible. It cared about the underlying process, which was still very much alive.

Ditto Everything. In fact, the installer supplied process IDs and said: these things must die before I proceed. Thus an application update that was supposed to save time had me back in an elevated PowerShell session, forcibly terminating processes by PID.

The command was simple enough: Stop-Process with the two reported IDs and -Force. But that’s hardly the point. I had already obeyed the apparent request to close the applications. Now I had to distinguish between closing an application’s visible window and exterminating the process that Adobe actually meant.

That’s a perfectly reasonable troubleshooting distinction. It’s a rather less charming requirement when updating a PDF reader.

WinGet Is the Messenger Here

To be fair to WinGet, I don’t think Windows Package Manager deserves the blame. WinGet finds the package, obtains the installer, and invokes it. At that point, the vendor’s installer gets a substantial say in how the remaining experience unfolds.

Adobe documents command-line deployment of Acrobat using Windows Installer technology. That helps explain why an apparently uniform WinGet operation can suddenly inherit some very Adobe-specific installation behavior.

In other words, WinGet can give applications the same starting line. It cannot make every vendor run the same race.

The In-App Updater Wins This Round

The irony is that Acrobat’s own updater has generally been faster and less fussy for me. Open Acrobat, invoke its update mechanism, let it finish, and get back to work. That’s not nearly as satisfying to a command-line devotee, but neither is hunting down PIDs because an installer refuses to believe that File Explorer is sufficiently closed.

This doesn’t make me question using WinGet every day. Far from it. For broad maintenance, WinGet upgrade… remains one of my favorite ways to see what needs attention and dispatch a bunch of updates quickly.

It inclines me, however, to treat Acrobat as a special case. If I’m already doing a general WinGet sweep, I’ll certainly let it take a crack at Acrobat. If Acrobat alone needs an update, though, I’ll probably use Adobe’s in-app mechanism and save myself the process-management sideshow.

Automation Has Limits

There is a small lesson here that applies beyond Acrobat. Automation is only as smooth as the least cooperative component in the list of tasks. A package manager can automate discovery, download, invocation, and reporting. It cannot erase every vendor-specific installer behavior hiding behind that neat command line.

Most of the time, that’s fine. WinGet saves me plenty of effort overall. But this particular update takes longer than the supposedly old-fashioned in-app route and requires more manual intervention.

So yes, I’m mildly vexed. Not table-flipping vexed. Not uninstall-Adobe-and-take-up-calligraphy vexed. Just enough to appreciate the absurdity. Here in Windows-World, that’s an oddly familiar sensation.

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

P3 Ultra Shows Some AI Chops

My recent AnythingLLM/Ollama adventure on the Lenovo ThinkStation P3 Ultra focused on utility. I wanted a capable local AI setup that could answer questions without acessing the cloud. Then a simple performance question came along: “How fast is this thing, really?” Ollama makes that easy to determine. Its verbose mode reports prompt-processing and output-generation statistics after a response. Once I knew where to look, the experiment practically designed itself. On the way, the P3 Ultra shows some AI chops, too.

I ran the installed Qwen3.6 model directly through Ollama rather than through AnythingLLM. That removes the front end from the timing exercise and lets Ollama report what its inference engine is doing. I deliberately chose a subject I know well: Windows Secure Boot. The prompt asked the model to explain, in roughly 300 words, how Secure Boot validates the boot chain. That made the answer long enough to produce a useful measurement instead of a tiny burst dominated by startup effects. FWIW, it was a pretty good answer, too.

How the P3 Ultra Shows Some AI Chops

The response turned out much longer than 300 words at 1,502 output tokens, which was fine for this purpose. Ollama reported 19.924866 seconds of evaluation time and an evaluation rate of 75.38 tokens per second. Total duration was ~20.7 seconds. The prompt itself contained 28 tokens, processed at 37.72 tokens per second.

For local-LLM performance, that 75.38 tokens-per-second evaluation rate is the headline number. It represents output generation, not model loading and not the time required to consume the prompt. The arithmetic checks out, too: 1,502 tokens over 19.924866 seconds lands at essentially the same 75.38 TPS that Ollama itself reported.

More important, the run felt fast. Numbers matter because they let us compare systems, but responsiveness is what makes a local AI system usable. Seventy-five generated tokens each second is comfortably beyond the rate at which I can read the answer as it appears. For interactive question-and-answer work, the P3 Ultra was not leaving me staring at the screen waiting for the next few words.

What Exactly Was Running?

A benchmark without the model details is not much of a benchmark. The next step was therefore ollama show qwen3.6:latest. My installed model identifies itself as the qwen35moe architecture with 35.5 billion parameters and Q4_K_M quantization. It advertises a 262,144-token context length and supports completion, vision, tools, and thinking. Thinking is enabled by default in the model metadata I inspected.

The Mixture-of-Experts detail matters. Qwen’s published model information describes Qwen3.6-35B-A3B as having 35 billion total parameters with 3 billion activated during inference. In other words, the big total parameter number should not be read as though every parameter participates equally in generating every token. That architecture helps explain why a model of this overall size can deliver lively local performance.

Ollama’s library also lists the Qwen3.6 35B Q4_K_M variant in this model family. My local installation reported 22 GB in ollama list. I prefer reporting what the machine itself told me about the artifact I actually ran rather than silently substituting a current download-page size.

CPU and GPU Share the Job

The final useful clue came from ollama ps while the model was still resident. That command reported the 22 GB Qwen3.6 model running with a 19%/81% CPU/GPU split, a 4,096-token allocated context, and the llamacpp runner. Thus the 75.38 TPS result did not come from a benchmark with the model reported as 100% GPU-resident. Some of the workload was offloaded to CPU/system memory.

There is another useful distinction here. The model can support a far larger context than the 4K context allocated for this particular run. For my short Secure Boot prompt, that was no handicap. It does mean I would record 4K as part of the test conditions. Change the context allocation, model quantization, hardware placement, prompt, or software stack and the throughput number can change with them.

One Run Is a Baseline, Not a Lab

I won’t present this single pass as a rigorous benchmark suite. It is better understood as a reproducible field measure. The model was identified, the prompt was substantial, the output was long enough to time meaningfully, and Ollama supplied token counts plus generation duration. Those pieces give me a useful baseline for the P3 Ultra as I continue working with AnythingLLM and Ollama.

If I decide to turn this into formal testing, the next step is obvious: use identical prompts, repeat each run several times, control warm versus cold model state, record the exact context allocation, and compare model variants under the same conditions. For now, though, 75.38 TPS tells me what I wanted to know. This workstation can make a decent-sized local model feel fairly interactive.

A PS4 Supplies a Fun Reality Check

My question about the P3 Ultra arose after I saw a Tom’s Hardware story about Garlic LLM running Qwen3.5-9B on a jailbroken PlayStation 4. The reported performance is 31 to 39 tokens per second for text chat and up to 43 tokens per second for code. Garlic LLM accomplishes that on a base or Slim PS4 by talking directly to the console’s GPU, which is a clever achievement by itself.

I can’t call this an apples-to-apples benchmark. The PS4 uses a different Qwen model, different quantization choices, a different inference implementation, and an unpublished prompt/test method in the Tom’s account. My P3 Ultra run used Qwen3.6, produced 1,502 tokens, and gave me Ollama’s timing data directly. Still, 75.38 TPS versus a reported maximum of 43 TPS makes a perfectly good informal reality check.

More tellingly, the P3 Ultra reached that rate with Qwen3.6-35B-A3B, a model whose published specification lists 35 billion total and 3 billion active parameters. I started this exercise wondering whether my compact workstation had respectable local-AI chops. The answer looks pretty clear: Heck, yeah! The P3 Ultra shows its AI colors nicely, indeed. I’m still using it, too, even though Copilot is back. I’ll be interested to see how things play out in the weeks and months ahead.

Facebooklinkedin
Facebooklinkedin

When Copilot Goes Bye-Bye, Local LLM Takes Over

Yesterday, Thursday, November 12, I got an unexpected lesson in AI continuity planning. Around lunchtime here in Central Texas, Microsoft 365 Copilot became unavailable to me. Outlook, Teams and other Microsoft 365 services were also caught up in a widespread service disruption. At the time I could only say to myself: “I wonder how Copilot goes bye-bye in this day and age?”

Why (and for How Long)
Copilot Goes Bye-Bye

Microsoft tracked the broader event as MO1550821. Reporting based on Microsoft’s service updates says that incident began at 1:26 PM Eastern, or 12:26 PM Central. The trouble was not a sudden flood of users. Microsoft said a number of servers unexpectedly became unavailable, putting extra strain on the infrastructure still standing. Automated health-check failures and an overwhelmed core process complicated recovery. The outage continued for many hours and into November 13 for some users.

In my case, that meant Copilot was essentially gone from noon through the end of my workday. The timing was especially inconvenient because I had four roughly 1,000-word pieces to produce for a hurry-up project (submissions starting NOW). Their themes were modernization, hybrid IT strategy, securing infrastructure for AI, and managing growing IT estates without growing budgets apace.

Necessity being the mother of invention, I decided this was a fine time to find out whether the Lenovo ThinkStation P3 Ultra could become its own AI writing workbench. Google AI helped me get there. By the end of the exercise, I had a local LLM workflow and all four articles completed. Sometimes an outage provides motivation that a normal workday does not.

Ollama Provides the Local AI Engine

The foundation is Ollama, which runs open models locally on Windows. I installed the Windows build and confirmed that its local API was available at http://127.0.0.1:11434. Ollama’s Windows documentation says the application runs in the background after installation and makes the ollama command available in PowerShell and other terminals.

My first check was simple: ollama list. There were no models aboard yet. I then pulled qwen3.6 and wound up using qwen3.6:latest as the model behind this writing experiment. Once downloaded, that model could run on the P3 Ultra instead of depending on somebody else’s cloud staying healthy and accessible.

Ollama for Windows: https://ollama.com/download/windows

AnythingLLM Turns Model Into Workspace

Ollama supplied the engine, but I needed a practical document-oriented front end. AnythingLLM Desktop filled that role. Its workspace approach let me collect source material for the  project, embed it, retrieve relevant files, and converse with the model around a defined body of documents.

Installation presented one Windows-like speed bump. Smart App Control blocked AnythingLLM from launching on this particular PC. I chose to disable SAC in Windows Security so I could proceed. That is a consequential security setting, not a step I recommend taking casually. Here, it was a calculated tradeoff on a machine I manage.

There was another wrinkle. AnythingLLM now includes its own local model runner, but I specifically wanted Ollama. In Settings, under AI Providers and LLM, I selected Ollama and pointed the base URL at http://127.0.0.1:11434. I also expanded the model context window to 32,768 tokens so larger source collections had useful breathing room. I was a bit non-plussed running out of tokens in AnythingLLM’s default workspace, let me tell you!

AnythingLLM Desktop: https://anythingllm.com/download

Blank Model Setting Throws a Curveball

My most interesting configuration glitch produced a wonderfully terse error: “model is required.” AnythingLLM’s newer interface auto-saves selections, so there was no missing Save button to blame. Instead, I discovered that my workspace had been created before I pulled qwen3.6. It had retained a blank model override.

Opening the workspace’s Chat Settings and explicitly choosing Ollama plus qwen3.6:latest cleared the problem. A fresh chat then caused Ollama to load the model into memory. That was the moment the collection of installers, settings and URLs turned into a functioning system.

From Experiment to 4 Finished Articles

For the actual writing job, I loaded the project’s text sources into the AnythingLLM workspace and used Save and Embed. Rather than pinning a huge pile of material into every prompt, I let retrieval do the heavy lifting. Then I worked through the articles section by section, keeping each piece focused on its assigned IT theme.

The result surprised me. This was not merely a laboratory demo showing that a local model could answer a prompt. The P3 Ultra became a useful production tool. In one afternoon, the local Ollama/AnythingLLM combination helped me finish four substantial articles while my normal cloud assistant was unavailable.

I am not giving up Copilot. Far from it. But yesterday changed my view of local AI. The lesson is less about replacing one assistant with another than eliminating a single point of failure. Cloud AI is convenient and powerful right up until the cloud goes away. Now, when that happens, the P3 Ultra has another answer: keep the sources local, load the model, and keep writing.

Here in Windows-World, it’s best to be ready for anything and everything. Sooner or later, that readiness will pay off. Long live local LLMs!

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

Iphone SMS Failure 2FA Cascade

Recently, my iPhone 12 developed a particularly inconvenient communications problem. SMS messages from multiple online services simply stopped showing up. Ordinary phone use looked normal, but two-factor authentication (2FA) did not. When a site wanted to send me a one-time code by SMS, that code often went MIA. That turned routine account maintenance into an obstacle course, and provoked an iPhone SMS failure 2FA cascade. Let me explain…

Finding & Fixing Iphone SMS Failure 2FA Cascade

After doing the usual checking, I called Spectrum, my wireless provider. That turned into a surprisingly positive support encounter. The network support representative worked the carrier side while I worked on the iPhone.

The prescription was straightforward. I reset the iPhone’s network settings (item 2 in lead-in graphic) while Spectrum reset and resynchronized things on its end. Apple’s documentation confirms that Reset Network Settings removes saved network settings, including Wi-Fi networks and passwords, cellular settings, and VPN and APN settings. It does not amount to erasing the phone.

Once both sides had been refreshed, SMS delivery returned to normal. Verification codes started arriving again. That’s the outcome that matters most. Whatever had become unsynchronized between handset and network was apparently cleared by rebuilding the relationship from both ends. I’m not sure what caused this, but it started happening aftera recent iOS update (26.7.2) on October 26.

Next Comes Account Cleanup…Sigh

Restoring SMS did not magically undo everything that happened while those messages were missing. Now I’m going through affected online accounts to make sure authentication, billing, and other notices are behaving normally.

That exercise immediately produced an unwelcome surprise at Box.com. I discovered a $500-plus invoice for online file-exchange service. The subscription covers three seats even though I’m using none (and don’t really need the subscription anymore).

Getting Outside the Box

I started investigating how to reduce that bill. Box’s published support information says paid accounts subject to its seat-reduction policy have a three-seat minimum. It also says seat decreases can be processed only at the end of the account term. Removing users by itself does not reduce subscription charges.

Refund language isn’t particularly comforting, either. Box says services are prepaid and generally non-refundable, including renewed accounts. Its support material does allow eligible customers to request a refund for a renewal charge through Billing, but that is a request, not a promise.

Those rules may make contractual sense from Box’s point of view. From where I sit, though, paying more than $500 for three seats when I’m using none makes little sense. If I cannot unwind a freshly discovered renewal, this may end a very long business relationship.

A Bigger Lesson For Yours Truly

The episode started as an iPhone messaging problem and turned into an account audit. That’s probably a useful takeaway. When SMS-based 2FA stops working across multiple unrelated services, don’t assume every account has suddenly broken. The common dependency may be the phone or carrier connection.

In my case, resetting network settings while Spectrum refreshed its side fixed my immediate SMS problem. The follow-on work is less pleasant, but perhaps equally valuable. I’m now checking the accounts that depend on those messages, fixing what needs fixing, and reconsidering services whose billing arrangements fall outside my pain threshold. Sometimes a communications failure tells you more than you expected to learn. Here in Windows-World, that means “It’s Tuesday.”

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

Revoking P16 CA-2011 Breaks Secure Boot Stalemate

For several days, my Lenovo ThinkPad P16 seemed stuck halfway through Microsoft’s Secure Boot certificate transition. The new 2023 certificates were present, but the Secure-Boot-Update task would not finish the job. Then I revoked the old Microsoft Windows Production PCA 2011 certificate. Finally, it looks like revoking P16 CA-2011 breaks Secure Boot stalemate!

The resulting Garlin check_UEFI-CA2023 audit is the kind of output Windows admins like to see, including yours truly. Every check passes. The Windows UEFI CA 2023 trust chain is active, the newer Boot Manager is in use, and the old PCA 2011 path is revoked.

What changed, and why did revocation apparently matter? That question is worth examining because this 2011-to-2023 transition is becoming increasingly important for Windows PCs.

P16 Breaks Secure Boot Stalemate

Before the final change, this P16 was not exactly broken. Secure Boot was on. Windows booted normally. The 2023 certificates had made their way into the firmware databases. Yet the overall migration remained incomplete.

Repeated efforts to trigger the Microsoft Secure-Boot-Update scheduled task did not transition to the expected state. The task sat at Ready, and Garlin’s checks continued to show that more work remained.

That distinction is useful. A system can remain operational while sitting between the old and new Secure Boot states. Seeing a scheduled task at Ready also does not prove that the complete certificate transition has occurred.

Microsoft Makes It a Staged Transition

Microsoft’s documentation helps explain why. Moving from the 2011 Secure Boot certificates to their 2023 replacements involves more than dropping a certificate into firmware. Microsoft says the change includes new Secure Boot certificates and a Windows Boot Manager signed by the updated trust. All those pieces work together as an explicit design.

Microsoft also treats revocation carefully. Its CVE-2023-24932 guidance warns that Secure Boot revocations can have persistent consequences. Once applied, they cannot simply be undone while Secure Boot remains in use. That’s a real reason why Microsoft has rolled related mitigations out in stages rather than treating them like an ordinary monthly update.

Enterprise guidance makes another dependency explicit. Adding Windows UEFI CA 2023 and untrusting Microsoft Windows Production PCA 2011 requires cooperation from device firmware. Differences among hardware and firmware therefore matter.

Revocation Supplies the Missing Shove

On my P16, requesting the PCA 2011 revocation was the move that finally altered the outcome. I would not claim that revoking PCA 2011 repaired a defective scheduled task. I cannot see enough of the task’s internal decision-making to verify that.

Nevertheless, the observable evidence supports a narrower and more useful conclusion. The machine had reached an intermediate Secure Boot state. Applying the revocation caused Windows and the firmware to complete the remaining transition work. Only then did the audit report the Secure Boot state as functionally complete and up-to-date.

That’s an important troubleshooting insight. When Secure-Boot-Update appears intransigent, the visible task state may be a symptom rather than the underlying cause. Certificate state, firmware state, Boot Manager signing and revocation state all need inspection.

Confirmation: (Mostly) Clean Garlin Check UEFI Results

That said, Garlin still reports two missing certificates.

These missing certificates serve different purposes from Windows UEFI CA 2023:

  • Microsoft UEFI CA 2023 signs third-party UEFI boot loaders and EFI applications.
  • Microsoft Option ROM UEFI CA 2023 signs third-party option ROMs.

They replace broader third-party trust previously supplied by the 2011 Microsoft UEFI certificate. Microsoft split the replacement into two certificates for finer control over third-party boot loaders and option ROMs.

Questioning the Final Garlin Repairs

However, the P16’s DB listing does not contain the old Microsoft Corporation UEFI CA 2011 certificate. Microsoft says the update task adds those two replacement certificates if the old Microsoft Corporation UEFI CA 2011 certificate exists in DB. It doesn’t so neither do they. Garlin’s script accurately observes that these two third-party certs are missing, but they don’t seem to interfere with proper boot behavior.

The decisive lines appear in the lead-in graphic as:

Windows Boot Manager [Windows UEFI CA 2023] is ALLOWED.
Registry: "WindowsUEFICA2023Capable" = 2
Registry: "UEFICA2023Status" = Updated
Windows BootMgr SVN 12.0
SkuSiPolicy.p7b is CURRENT.

The next screencap shows the tail-end of the Garlin check script results. I’ve run this repair three or more times and it never makes an impact on P16. That’s why I think it’s done, even though the check script still calls for those certs. Copilot says the 0x5800 modifier has a special meaning — namely:

  • 0x0800 requests installation of Microsoft Option ROM UEFI CA 2023 into DB.
  • 0x1000 requests installation of Microsoft UEFI CA 2023 into DB.
  • 0x4000 is a conditional modifier. It tells Windows to install those two certificates only if DB already contains the old Microsoft Corporation UEFI CA 2011 certificate.

Add ’em all together and  you get — wait for it — 0x5800. ‘Nuff said.

As far as I’m concerned, the P16 is fully updated and compliant. I had to do some learning to understand why. I did, and now I’m satisfied.

Further Reading

Microsoft Support, “How to manage the Windows Boot Manager revocations for Secure Boot changes associated with CVE-2023-24932” (KB5025885).
Microsoft Support, “Enterprise Deployment Guidance for CVE-2023-24932” (KB5053946).
Microsoft Support, “Updating Windows bootable media to use the PCA2023 signed boot manager” (KB5053484).
Microsoft Support, “When Secure Boot certificates expire on Windows devices” (KB5079373).

Facebooklinkedin
Facebooklinkedin

Steps to an Ecology of Boot

With apologies to Gregory Bateson, I’m reminded of his work from the tangle of elements around booting to Windows 11 rescue media in the era of Secure Boot. Indeed, backups don’t count for much if their rescue media won’t boot. I rediscovered that old truth while testing Macrium Reflect X rescue media on my Lenovo ThinkPad P16. What looked like a simple USB boot test turned into a useful tour of modern Windows boot ecology. It also defined (for me, at least) the essential steps to an ecology of boot in today’s world.

Think about it: the word “ecology” fits. Modern booting isn’t one thing. It’s an interaction among firmware, Secure Boot certificates, revocation policy, boot files, BitLocker, virtualization-based security, the recovery environment, and even the particular USB flash drive you choose.

Steps to an Ecology of Boot: First, Update Rescue Media

My first concern was the Macrium rescue image itself. I had already been working on a PowerShell repair script, fixmrrdv6.ps1, to bring its boot components into line with current Secure Boot requirements. The script updates the external EFI boot manager and relevant files inside boot.wim.

Garlin’s Check_BootMedia.ps1 supplied the essential reality check. An earlier test showed the external Windows Boot Manager as BANNED even though components inside boot.wim were ALLOWED. After correcting the source and running version 6 of the repair script, the external boot manager, the WinPE boot manager, and winload.efi all reported ALLOWED. The boot manager showed SVN 12.0.

That was lesson one: a rescue UFD can look perfectly ordinary in File Explorer yet contain boot components that current Secure Boot policy won’t accept.

Step 2: Get the $#@^! UFD Recognized in UEFI

Next came hardware discovery. A SanDisk 32 GB UFD (USB Flash Drive) didn’t appear in the P16 F12 boot menu. I moved it from one USB-A port to another. No joy. I also encountered the curious “USB FDD” boot choice while working through Windows recovery options. Selecting it did not produce a successful rescue boot.

At that point the problem had stopped looking purely like Secure Boot. If firmware won’t enumerate a device as a boot candidate, fixing the files on that device won’t go anywhere.

So I changed media. I built fresh Macrium rescue media on other UFDs, including a Mushkin Ventura Pro. Ultimately, an ADATA S102 became the device that successfully booted the P16. Go figure!

Step 3: Slogging Through Security Layers

The P16 sports a full complement of modern Windows protections. Secure Boot was on. BitLocker protected C:. Virtualization-based security and Device Guard were in the mix. That’s good for normal operation, but it introduces multiple variables when testing alternate boot media.

I suspended BitLocker protection for the experiment. I also temporarily turned Device Guard/VBS off. That did not make Windows “recognize USB.” Instead, it removed another security and code-integrity variable while testing whether or not the repaired rescue environment could actually start.

Importantly, Secure Boot stayed on. That made the successful test meaningful. I wasn’t simply bypassing the very mechanism I wanted the rescue disk to comply with.

Step 4: The Boot Circle Shows Up from the Rescue Disk

With the ADATA rescue UFD in place and the test conditions sorted out, I initiated the alternate boot. The P16 went black for quite a while. Then the familiar spinning circle appeared. Finally, Macrium Reflect’s WinPE rescue environment appeared.

That was the result I wanted. I opened a command prompt inside WinPE and later used wpeutil reboot to return the P16 to Windows.

Back in the running OS, I restored the normal protection state. BitLocker once again reported ProtectionStatus On. Subsequent checks showed Secure Boot on and virtualization-based security running.

What Did I Learn From This Tapdance?

The biggest lesson is that “bootable USB” is no longer a yes/no thing. A UFD may contain the right partition, filesystem, EFI directory, boot.wim, and loader files, yet still fail somewhere along the path from firmware enumeration to Windows PE.

Current Secure Boot policy makes its contents matter. BitLocker makes boot-state changes matter. Device Guard and VBS add another enforcement layer. Firmware decides whether the UFD works at all. And apparently the physical flash device matters, too.

That last point remains a mystery. The ADATA S102 worked where the Mushkin Ventura Pro did not. I don’t yet have a satisfying technical explanation for that. What I do have is a repeatable successful test using the ADATA. So that’s what I’ll use.

That’s troubleshooting in a nutshell. Change one variable where possible. Verify the state at every layer. Keep good tools handy. And never assume your rescue disk can rescue anything until you’ve actually booted it and seen it work. Here in Windows-World, rescue isn’t guaranteed unless you check it before the brown stuff hits the whirling blades!

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