All posts by Ed Tittel

Full-time freelance writer, researcher and occasional expert witness, I specialize in Windows operating systems, information security, markup languages, and Web development tools and environments. I blog for numerous Websites, still write (or revise) the occasional book, and write lots of articles, white papers, tech briefs, and so forth.

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

No Zebras Here…

Last night, Flo6 suffered one of those Windows mystery crashes that gets my attention without quite setting off the alarm bells. The machine came back, appeared normal, and gave me no immediate reason to suspect a larger failure. Even so, unexplained crashes are invitations to look around. This morning I did exactly that. I’m pleased to report that all indications say no zebras here in the sense of nothing unusual, untoward, or outright signs of pathology.

Figuring Out What “No Zebras Here” Means…

My first stop was DISM, Microsoft’s Deployment Image Servicing and Management tool. I ran the health scan against the online Windows image. This was not a case where I went fishing and came up empty: /ScanHealth reported that the component store was repairable. In other words, Windows had found something worth fixing.

DISM Goes to Work

That led directly to the standard repair pass with DISM /Online /Cleanup-Image /RestoreHealth. Microsoft recommends running DISM before System File Checker because DISM repairs the Windows image that SFC can use as its repair source. That sequence matters when you are trying to distinguish image trouble from damaged protected system files.

RestoreHealth took its sweet time. The progress indicator bogged down in the low-to-upper 60-percent range for almost 10 minutes. That can look unnerving when you are staring at a supposedly stuck command. In this case, though, the servicing logs kept moving and the percentage eventually advanced to 68.7 percent. A little later it jumped to 100 percent and reported that the restore operation had completed successfully.

That behavior is worth remembering. A slow DISM percentage does not necessarily mean a hung DISM process. When Windows is servicing the component store, the interesting evidence is whether the process is still doing work, not whether its progress meter provides constant entertainment.

SFC Supplies the Reassuring Part

Once DISM finished, I followed with sfc /scannow. This is the System File Checker pass that examines protected Windows system files. Microsoft documents this same DISM-then-SFC sequence for repairing missing or corrupted system files.

This time the result could hardly have been cleaner: Windows Resource Protection did not find any integrity violations. That tells me the protected system files in the running installation passed SFC’s verification after DISM repaired the running Windows image.

That distinction is key. We know the component store had a repairable problem because DISM said so. We also know RestoreHealth completed successfully. But SFC didn’t find damaged protected system files afterward. I therefore have evidence of a repair, not evidence of a Windows installation falling apart. Phew!

Hiccup, Not Walking Pneumonia

Could the component-store issue be related to last night’s crash? Certainly possible. But the evidence  doesn’t show which came first. The crash might have exposed the problem, contributed to it, or simply occurred at roughly the same time. One crash plus a successfully repaired component store plus a clean SFC pass is not enough for me to diagnose a chronic illness.

That is where my usual troubleshooting rule kicks in: when you hear hoofbeats, think horses before zebras. I am inclined to call this a hiccup rather than the Windows equivalent of walking pneumonia. Flo6 got checked, Windows found something repairable, DISM repaired it, and SFC gave the active system files a clean bill of health. It’s OK, so I’m OK, too.

What Happens Next?

For now, the prescription is deliberately boring. Reboot Flo6, keep using it, and watch what happens. I’m not going to pile more repairs on top of a machine that currently passes its integrity check.

If another crash pops up, the story changes. A repeat failure establishes a pattern. That’s when Reliability Monitor, Event Viewer, dump information, and the precise timing of the failure become more interesting than another round of generic repairs. Until then, I have one unexplained crash and one completed repair cycle.

No zebras here. At least not yet. Stay tuned: I’ll keep you posted. Here in Windows-World, the next surprise is always just around the corner. I’m hoping it might be a pleasant one, rather than something more onerous. We’ll see…

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

Secure Boot Values Vary By Version

The most recent Patch Tuesday brought an interesting Secure Boot wrinkle to my Windows 11 test fleet. Production and Insider Preview systems now report different component versions, even though both appear fully updated. That sounds contradictory at first. A closer look says otherwise, even as Secure Boot values vary by version.

What’s Involved When Secure Boot Values Vary By Version?

On my production Windows 11 26H2 PCs, Garlin’s Secure Boot check reports SVN 12.0 and SkuSiPolicy version 3.0.0.20. My Insider Preview systems remain on Windows 11 25H2. There, the tool reports SVN 12.0 as well, but with a different associated file version and SkuSiPolicy 3.0.0.19.

The temptation is to assume that .19 is behind .20 and therefore needs fixing. Garlin says not. On both groups of systems, its final verdict is the same: “SUCCESS: UPDATES ARE FINISHED.”

Secure Boot State Matters More than Version Numbers

That result is the key to understanding what’s happening. Secure Boot servicing does not require every supported Windows branch to carry identical files. Microsoft says Windows 11 versions 24H2, 25H2 and 26H2 share a common servicing foundation. Version 26H2 can be enabled on eligible systems through an enablement package.

At the same time, Microsoft’s November 10, 2026 security update continues the Secure Boot certificate transition. Microsoft says the update adds more high-confidence device targeting data, expanding the population eligible to receive newer Secure Boot certificates automatically through Windows Update.

Windows release identity, individual Secure Boot component versions and Secure Boot remediation state are related. But they are not the same measurement, and they need not line up in synch.

SVN 12.0 Is Reassuring

For me, the most important common value is SVN 12.0. Both Production and Insider Preview have reached that security version number even though their SkuSiPolicy revisions differ.

That makes the .19 versus .20 split look like a branch-specific payload distinction rather than an incomplete update. I have found no Microsoft documentation that says SkuSiPolicy 3.0.0.20 is mandatory before Secure Boot remediation is considered complete.

Garlin’s identical success result reinforces that take. The tool sees both configurations as having completed the applicable Secure Boot update sequence.

Insider Doesn’t Mean Every File Is Newer

There’s another useful lesson here. We often think of Windows Insider Preview as automatically ahead of Production. That is true for many operating-system changes, but it does not mean every individual serviced component must carry a higher version number.

Right now my Production systems have moved to the Windows 11 26H2 designation, while my Insider Preview installations still identify as 25H2. Production also happens to have a newer SkuSiPolicy revision.

If It Ain’t Broke…

I won’t copy SkuSiPolicy 3.0.0.20 from Production to those Insider machines merely to force congruence. Secure Boot is specifically intended to maintain a trusted boot chain. Manually transplanting policy files because one version number looks newer would substitute my judgment for Windows servicing.

For now, the practical rule is simple. Check the security state, not just individual file versions. If SVN is current, Secure Boot is operating normally, and Garlin reports “UPDATES ARE FINISHED,” differing payload revisions can still describe fully serviced Windows installations. Here in Windows-World that means Secure Boot is A-OK. Good!

One More Thing…

After the Production update, I DID have to run Update_UEFI-CA2023.ps1 -SkuSiPolicy and reboot my production machines. That’s what took that value from 3.0.0.19 to 3.0.0.20 on those machines. After that Garlin’s check tool reports complete success as shown in the right-side half of the lead-in graphic. This is becoming a “thing to check” for Windows admins after applying Windows Update packages, especially Patch Tuesday CUs.

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

Repair Install Requires Local Logins for Working RDP

Here’s an interesting Windows 11 gotcha I ran into after a recent repair install on RyzenOfc. Remote Desktop worked perfectly with a local administrator account, but my usual Microsoft account refused a known-good password. The eventual fix was surprisingly simple: I had to log into RyzenOfc locally with that Microsoft account and its password once. Hence this post’s title: repair install requires local logins for working RDP.

That local login triggered the familiar “Setting a few things up…” sequence. After Windows finished its abbreviated OOBE-style setup, the same Microsoft account immediately worked for RDP from Flo6. Along the way, PowerShell provided some useful clues about what had survived the repair install and what had not.

Why Repair Install Requires Local Logins

From the get-go, I could RDP from Flo6 into RyzenOfc using the local administrator account LocalU. That eliminated a long list of suspects. The network path worked, Remote Desktop was enabled, and the target system was accepting RDP connections. Indeed, the failure was specific to my Microsoft account.

Windows returned the wonderfully nonspecific message “Your credentials did not work.” I knew the password was correct, so I started by examining the accounts RyzenOfc knew about.

PowerShell Exposes 2 MSAs

This command listed the local account records and their origins:

Get-CimInstance Win32_UserAccount -Filter "LocalAccount=True" |
Select-Object Name, Caption, SID, Disabled

The interesting entries were ed and etitt. Both showed up as MicrosoftAccount identities (aka MSAs). I already knew etitt belonged to an old, obsolete  Microsoft account. That made ed, with SID ending in -1002, the account of interest. In fact, that’s my current go-to user account.

Next I checked RDP and administrator group membership:

Get-LocalGroupMember -Group "Remote Desktop Users"

Get-LocalGroupMember -Group “Administrators”

That produced another important clue. RYZENOFC\ed was already a member of Remote Desktop Users. RYZENOFC\etitt and LocalU were administrators. Thus the ed account did not lack RDP permission. Adding it to Administrators would have treated the symptom as a permissions problem when the evidence pointed elsewhere.

Missing Profile = Smoking Gun

I then looked at the account objects more closely:

Get-LocalUser |
Select-Object Name, SID, PrincipalSource, Enabled, LastLogon

Both ed and etitt were enabled and identified as MicrosoftAccount principals. But a query for their Windows profiles changed the picture:

Get-CimInstance Win32_UserProfile |

Where-Object SID -in @(
‘S-1-5-21-144170778-2336474949-3120614169-1001’,
‘S-1-5-21-144170778-2336474949-3120614169-1002’) |
Select-Object LocalPath, SID, Loaded, LastUseTime

Only the old etitt identity appeared, mapped to C:\Users\etitt. There was no Win32_UserProfile entry for ed. RyzenOfc knew that ed existed and even knew it was allowed to use Remote Desktop, but Windows had not yet initialized that user environment following the repair install.

Local Login Closes the Loop

That observation reminded me of something important: I had not logged into RyzenOfc with the ed@edtittel.com/password combination since performing a repair install a couple of weeks earlier. I had been relying on Windows Hello rather than forcing a conventional password login.

So I did exactly that at RyzenOfc. I selected the ed account, chose password sign-in, and supplied the known-good Microsoft account password. Windows responded with “Setting a few things up…” and went through the familiar first-login setup sequence.

That message explained a lot. The Microsoft account registration had survived, but Windows still needed to finish initializing the user’s post-repair environment. The password-based sign-in also gave Windows a fresh interactive authentication event for that Microsoft account on the target PC.

THEN, RDP Gets to Workin’

Windows Hello and a Microsoft account password are related to the same identity, but they are not interchangeable credentials. A Hello PIN is tied to the device and protected through Windows Hello mechanisms. An ordinary RDP connection using a Microsoft account password needs the target Windows installation to be able to validate that password-based identity.

Microsoft documentation describes Windows Hello as using cryptographic keys, while Microsoft community reports describe RDP failures after setup when password-based sign-in has not been established locally. Those reports also describe a successful local password login as restoring RDP password authentication.

That matches my RyzenOfc experience. Once the local login completed account and profile setup, I returned to Flo6 and connected using the ed Microsoft account. This time RDP accepted the same password it had rejected before.

Here Cometh the Lesson

The practical takeaway is straightforward. After a Windows repair install, don’t assume a preserved Microsoft account is fully ready for every authentication path just because Windows still lists it.

If RDP works with a local administrator but rejects a known-good Microsoft account password, check the account source, Remote Desktop Users membership, and Win32_UserProfile state before changing security policy. If the Microsoft-account profile has not been initialized, perform one local interactive login using the actual password rather than the PIN.

In my case, that little “Setting a few things up…” message told the story. Windows was finishing work the repair install had left pending. Once it completed, RDP was back in business. Here in Windows-World, I count that as a win!

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