Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

make the windows install one-liner work and document it (#3319)

kt62a74e3caa67
diff --git a/.github/workflows/windows-runtime-triage.yml b/.github/workflows/windows-runtime-triage.yml
index 3281e17635..56ec0b5e3f 100644
--- a/.github/workflows/windows-runtime-triage.yml
+++ b/.github/workflows/windows-runtime-triage.yml
@@ -100,6 +100,55 @@ jobs:
run: |
pwsh -NoProfile -File scripts/release/test_windows_install.ps1 2>&1 | Tee-Object -FilePath win-install-e2e.log
exit $LASTEXITCODE
+ # The Windows channel-fallback regression (the local-channel unit test
+ # for the stable->beta fallback the plain one-liner rides): a stable
+ # channel without a win32-x64 row falls back to beta with the notice,
+ # and an explicitly requested channel refuses with the beta route.
+ - name: windows channel-fallback unit (install.ps1 stable->beta)
+ id: channel_fallback
+ continue-on-error: true
+ shell: pwsh
+ run: |
+ pwsh -NoProfile -File scripts/release/test_windows_channel_fallback.ps1 2>&1 | Tee-Object -FilePath win-channel-fallback.log
+ exit $LASTEXITCODE
+ # THE RAW ONE-LINER on the real channel, end to end: install.ps1
+ # itself from raw.githubusercontent (the ref under test - on main it
+ # is the README's shipped command), then the pointer, the manifest,
+ # the win32-x64 tarball, and its sums from the real bucket, the real
+ # default prefix ($HOME\.local), the real stable->beta Windows
+ # fallback, and the launcher answering --version. The transcript
+ # (win-raw-one-liner.log) is the evidence: the install transcript,
+ # the --version output, and the exit codes.
+ - name: the raw one-liner on the real channel (irm | iex)
+ id: raw_one_liner
+ continue-on-error: true
+ shell: pwsh
+ env:
+ RAW_REF: ${{ inputs.ref || github.ref }}
+ run: |
+ Get-ChildItem Env: | Where-Object { $_.Name -like 'PRIME_AGENT_*' } |
+ ForEach-Object { Remove-Item -Path ("Env:" + $_.Name) -ErrorAction SilentlyContinue }
+ Start-Transcript -Path win-raw-one-liner.log
+ $installExit = 0
+ try {
+ irm "https://raw.githubusercontent.com/PrimeIntellect-ai/prime-agent/$env:RAW_REF/install.ps1" | iex
+ } catch {
+ $installExit = 1
+ Write-Output "RAW_ONE_LINER: the one-liner threw: $($_.Exception.Message)"
+ }
+ $launcherExit = 0
+ try {
+ & (Join-Path $HOME '.local\bin\prime-agent.cmd') --version
+ $launcherExit = $LASTEXITCODE
+ Write-Output "RAW_ONE_LINER: launcher --version exit $launcherExit"
+ if ($launcherExit -ne 0) { $installExit = 1 }
+ } catch {
+ $installExit = 1
+ Write-Output "RAW_ONE_LINER: the launcher did not answer --version: $($_.Exception.Message)"
+ }
+ Write-Output "RAW_ONE_LINER: install exit $installExit"
+ Stop-Transcript
+ exit $installExit
- name: pa-cli battery (unit + the e2e set)
id: pa_cli
continue-on-error: true
@@ -112,10 +161,10 @@ jobs:
- name: Summary + the overall verdict
shell: pwsh
run: |
- $summary = "WIN_BATTERY pa-types=${{ steps.pa_types.outcome }} pa-core=${{ steps.pa_core.outcome }} pa-daemon=${{ steps.pa_daemon.outcome }} pa-tui=${{ steps.pa_tui.outcome }} pa-cli=${{ steps.pa_cli.outcome }} install-e2e=${{ steps.install_e2e.outcome }}"
+ $summary = "WIN_BATTERY pa-types=${{ steps.pa_types.outcome }} pa-core=${{ steps.pa_core.outcome }} pa-daemon=${{ steps.pa_daemon.outcome }} pa-tui=${{ steps.pa_tui.outcome }} pa-cli=${{ steps.pa_cli.outcome }} install-e2e=${{ steps.install_e2e.outcome }} channel-fallback=${{ steps.channel_fallback.outcome }} raw-one-liner=${{ steps.raw_one_liner.outcome }}"
Add-Content -Path win_battery_summary.log -Value $summary
Write-Output $summary
- if (@("${{ steps.pa_types.outcome }}", "${{ steps.pa_core.outcome }}", "${{ steps.pa_daemon.outcome }}", "${{ steps.pa_tui.outcome }}", "${{ steps.pa_cli.outcome }}", "${{ steps.install_e2e.outcome }}") -contains 'failure') { exit 1 }
+ if (@("${{ steps.pa_types.outcome }}", "${{ steps.pa_core.outcome }}", "${{ steps.pa_daemon.outcome }}", "${{ steps.pa_tui.outcome }}", "${{ steps.pa_cli.outcome }}", "${{ steps.install_e2e.outcome }}", "${{ steps.channel_fallback.outcome }}", "${{ steps.raw_one_liner.outcome }}") -contains 'failure') { exit 1 }
- name: Upload the per-crate logs
if: always()
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
@@ -128,5 +177,7 @@ jobs:
pa-tui_win.log
pa-cli_win.log
win-install-e2e.log
+ win-channel-fallback.log
+ win-raw-one-liner.log
win_battery_summary.log
if-no-files-found: warn
diff --git a/README.md b/README.md
index 3ce4fdfff8..bce05fd9cd 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ Prime Agent is an open-source coding and research agent for general and long-run
## Install
-Install the latest build with the one-command installer (every push to the `rust` branch publishes a fresh rolling beta; the stable channel ships on release):
+Install the latest stable version with the one-command installer:
```bash
curl -fsSL https://app.primeintellect.ai/prime-agent/install.sh | sh
@@ -52,10 +52,6 @@ On Windows, install from PowerShell:
irm https://app.primeintellect.ai/prime-agent/install.ps1 | iex
```
-The sh one-liner also works under Git Bash on Windows. Both installers publish the same layout (the launcher under `$HOME\.local\bin`, the payload under `$HOME\.local\share\prime-agent`) and read the same release channel: darwin (arm64/x64), linux (arm64/x64), and windows (x86_64, `win32-x64`).
-
-The served installer and everything it downloads — the version pointers, the platform tarballs, the checksums — come from the same domain: no GitHub URL is on the user path.
-
## Why Prime Agent
Prime Agent combines a persistent Python control environment with durable harness state, so useful working context and reusable operating patterns can outlive a single chat window.
diff --git a/install.ps1 b/install.ps1
index 1843f0ffb9..94f23206f3 100644
--- a/install.ps1
+++ b/install.ps1
@@ -5,6 +5,11 @@
#
# irm https://app.primeintellect.ai/prime-agent/install.ps1 | iex
#
+# The repo copy's defaults are the same bucket-root base, so the raw form
+# works out of the box too (the README's Windows command):
+#
+# irm https://raw.githubusercontent.com/PrimeIntellect-ai/prime-agent/main/install.ps1 | iex
+#
# The Git Bash route is the same channel through install-rust.sh (the sh
# one-liner `curl -fsSL .../install.sh | sh` under Git Bash/MSYS2/Cygwin);
# this script is the PowerShell-native form. Both routes publish the SAME
@@ -18,6 +23,12 @@
# verified before anything is published. NO GITHUB SURFACE anywhere in the
# user path.
#
+# THE WINDOWS CHANNEL FALLBACK: the stable releases predate Windows
+# support, so the stable manifest carries no win32-x64 row until the first
+# stable release ships one; a default-channel Windows install falls back
+# to the beta channel with a printed notice, and a channel asked for by
+# name refuses instead (the beta route spelled out).
+#
# NO TYPESCRIPT TAKEOVER STEPS: the TypeScript product never shipped a
# Windows build, so there is no TS daemon, native install, or npm package
# to retire here — this installer publishes the Rust payload and stops
@@ -79,7 +90,8 @@ try {
# --- the knobs ----------------------------------------------------------------
$baseUrl = if ($env:PRIME_AGENT_DOWNLOAD_BASE_URL) { $env:PRIME_AGENT_DOWNLOAD_BASE_URL } else { $DownloadBaseUrlDefault }
-$channel = if ($env:PRIME_AGENT_RELEASE_CHANNEL) { $env:PRIME_AGENT_RELEASE_CHANNEL } else { $ReleaseChannelDefault }
+$channelRequested = $env:PRIME_AGENT_RELEASE_CHANNEL
+$channel = if ($channelRequested) { $channelRequested } else { $ReleaseChannelDefault }
$versionPin = $env:PRIME_AGENT_VERSION
$prefix = if ($env:PRIME_AGENT_RUST_PREFIX) { $env:PRIME_AGENT_RUST_PREFIX } else { Join-Path $HOME '.local' }
@@ -103,9 +115,9 @@ if (@('stable', 'beta') -notcontains $channel) { Fail "unknown release channel:
# a directory path, not an existing FILE.
if (Test-Path $prefix -PathType Leaf) { Fail "the install prefix names an existing file: $prefix" }
-# The channel files: the pointer names the version, the manifest the rows.
-$manifestName = if ($channel -eq 'beta') { 'beta.json' } else { 'latest.json' }
-$pointerName = $channel
+# The channel files: the pointer (<base>/stable or <base>/beta) names the
+# version, the channel manifest (<base>/latest.json or <base>/beta.json)
+# the rows; the version resolution below reads the pair per channel.
# The platform this script serves: the channel manifest's win32-x64 row
# (the TS NATIVE_PLATFORMS spelling pa-core::update::install reads) — a
@@ -137,50 +149,90 @@ function ExpectedFileName($version, $platform) {
# PAIR, retrying once on a version mismatch (the publish writes the
# manifest first and the pointer second: a read between the two writes sees
# the old pointer with the new manifest — a transient window, not a broken
-# channel — install-rust.sh's consistency retry).
-$manifest = $null
-$manifestVersion = $null
-$row = $null
-if ($versionPin) {
- $version = $versionPin.Trim().TrimStart('v')
- Write-Host "installing prime-agent $version (pinned) from the $channel channel ($platform)"
-} else {
+# channel — install-rust.sh's consistency retry). The pair reader is a
+# function so the Windows channel fallback below re-resolves the beta
+# channel through the same retry discipline.
+function Read-ChannelPair($channelName) {
+ $pairPointer = $channelName
+ $pairManifestName = if ($channelName -eq 'beta') { 'beta.json' } else { 'latest.json' }
$attempt = 0
while ($true) {
# The pointer is published bare ("1.2.3") but a `v`-prefixed
# spelling is a valid historical form - normalize it (the manifest's
# version is bare; the release prefix and the artifact names carry
# no extra `v` - the bots' finding).
- $version = (Invoke-RestMethod -Uri "$baseUrl/$pointerName").ToString().Trim().TrimStart('v')
- if (-not $version) { Fail "could not resolve the latest $channel version from $baseUrl/$pointerName" }
- $manifest = Invoke-RestMethod -Uri "$baseUrl/$manifestName"
- $manifestVersion = ($manifest.version).ToString().TrimStart('v')
- if ($manifestVersion -eq $version) { break }
+ $pairVersion = (Invoke-RestMethod -Uri "$baseUrl/$pairPointer").ToString().Trim().TrimStart('v')
+ if (-not $pairVersion) { Fail "could not resolve the latest $channelName version from $baseUrl/$pairPointer" }
+ $pairManifest = Invoke-RestMethod -Uri "$baseUrl/$pairManifestName"
+ $pairManifestVersion = ($pairManifest.version).ToString().TrimStart('v')
+ if ($pairManifestVersion -eq $pairVersion) { break }
$attempt += 1
if ($attempt -gt 2) {
- Fail "the $channel manifest's version $manifestVersion does not match the channel pointer $version (re-read twice; the channel looks inconsistent)"
+ Fail "the $channelName manifest's version $pairManifestVersion does not match the channel pointer $pairVersion (re-read twice; the channel looks inconsistent)"
}
- Write-Host "the $channel pointer and manifest disagree (a publish's consistency window); re-reading the pair..."
+ Write-Host "the $channelName pointer and manifest disagree (a publish's consistency window); re-reading the pair..."
Start-Sleep -Seconds 1
}
- Write-Host "installing prime-agent $version from the $channel channel ($platform)"
+ return [pscustomobject]@{ Version = $pairVersion; Manifest = $pairManifest }
}
-# --- the channel manifest row (unpinned) / the naming contract (pinned) ------
-$expectedFile = ExpectedFileName $version $platform
-if (-not $versionPin) {
- foreach ($candidate in @($manifest.binaries_v2) + @($manifest.binaries)) {
+# The manifest's row for this platform: the channel naming contract gives
+# the file name the row must carry (the reader's own rule,
+# pa-core::update::release::parse_channel_manifest).
+function Find-PlatformRow($rowManifest, $rowVersion) {
+ $expected = ExpectedFileName $rowVersion $platform
+ $found = $null
+ foreach ($candidate in @($rowManifest.binaries_v2) + @($rowManifest.binaries)) {
if ($candidate -and $candidate.platform -eq $platform) {
- if ($candidate.file -ne $expectedFile) {
- Fail "the manifest's $platform row names '$($candidate.file)' instead of the channel naming '$expectedFile'"
+ if ($candidate.file -ne $expected) {
+ Fail "the manifest's $platform row names '$($candidate.file)' instead of the channel naming '$expected'"
}
- $row = $candidate
+ $found = $candidate
break
}
}
- if (-not $row) { Fail "no artifact row for platform $platform in the $channel manifest" }
- if ($row.sha256 -notmatch '^[0-9a-f]{64}$') { Fail "the channel manifest's sha256 for $expectedFile is malformed" }
+ return $found
+}
+
+$manifest = $null
+$row = $null
+if ($versionPin) {
+ $version = $versionPin.Trim().TrimStart('v')
+ Write-Host "installing prime-agent $version (pinned) from the $channel channel ($platform)"
} else {
+ $pair = Read-ChannelPair $channel
+ $version = $pair.Version
+ $manifest = $pair.Manifest
+ $row = Find-PlatformRow $manifest $version
+ # THE WINDOWS CHANNEL FALLBACK (the operator's real-machine report,
+ # 2026-10-02): the plain one-liner threw "no artifact row for platform
+ # win32-x64 in the stable manifest" - the stable releases predate
+ # Windows support, and the win32-x64 build ships on the beta channel
+ # only. A channel the user asked for BY NAME gets the honest refusal
+ # (the beta route spelled out); the DEFAULT channel falls back to beta
+ # with a printed notice, so the plain one-liner just works.
+ if (-not $row) {
+ if ($channelRequested -and $channelRequested -ne 'beta') {
+ Fail ('the explicitly requested ' + $channelRequested + ' channel ships no ' + $platform + ' build yet; Windows builds ride the beta channel - re-run with the beta channel: ' + '$env:PRIME_AGENT_RELEASE_CHANNEL = ''beta''; irm https://raw.githubusercontent.com/PrimeIntellect-ai/prime-agent/main/install.ps1 | iex')
+ } elseif ($channel -ne 'beta') {
+ Write-Host "$channel does not ship Windows builds yet; installing from the beta channel"
+ $channel = 'beta'
+ $pair = Read-ChannelPair $channel
+ $version = $pair.Version
+ $manifest = $pair.Manifest
+ $row = Find-PlatformRow $manifest $version
+ if (-not $row) { Fail "no artifact row for platform $platform in the $channel manifest either (the Windows fallback found no beta build)" }
+ } else {
+ Fail "no artifact row for platform $platform in the $channel manifest"
+ }
+ }
+ if ($row.sha256 -notmatch '^[0-9a-f]{64}$') { Fail "the channel manifest's sha256 for $(ExpectedFileName $version $platform) is malformed" }
+ Write-Host "installing prime-agent $version from the $channel channel ($platform)"
+}
+
+# --- the channel manifest row (unpinned) / the naming contract (pinned) ------
+$expectedFile = ExpectedFileName $version $platform
+if ($versionPin) {
Write-Host "pinned ${version}: installing from the versioned release prefix (the channel naming contract names the row)"
}
diff --git a/scripts/release/test_windows_channel_fallback.ps1 b/scripts/release/test_windows_channel_fallback.ps1
new file mode 100644
index 0000000000..2bd3ffce8f
--- /dev/null
+++ b/scripts/release/test_windows_channel_fallback.ps1
@@ -0,0 +1,148 @@
+# test_windows_channel_fallback.ps1 — the install.ps1 Windows channel-fallback
+# regression test (the windows battery's third install gate).
+#
+# WHAT IT PROVES (the operator's real-machine report, 2026-10-02: the plain
+# one-liner threw "no artifact row for platform win32-x64 in the stable
+# manifest"):
+# 1. a default-channel install against a stable channel that carries no
+# win32-x64 row falls back to beta, prints the notice, and publishes
+# the beta payload (the .prime-agent-install marker names beta);
+# 2. an explicitly requested channel without a win32-x64 row refuses with
+# the beta one-liner spelled out — the fallback never overrides a
+# channel the user asked for by name.
+#
+# The payload is a stub tarball (a placeholder prime-agent.exe): this test
+# exercises the channel resolution and the fallback, not the binary — the
+# real-binary proof is the install e2e beside it (test_windows_install.ps1),
+# and the real-channel proof is the raw one-liner check in the same battery.
+#
+# Usage (from the repo root, on windows-latest):
+# pwsh -NoProfile -File scripts/release/test_windows_channel_fallback.ps1
+
+$ErrorActionPreference = 'Stop'
+
+$repo = (Get-Location).Path
+$scratch = Join-Path ([IO.Path]::GetTempPath()) ("prime-agent-channel-fallback-{0}" -f [Guid]::NewGuid().ToString('N'))
+New-Item -ItemType Directory -Path $scratch | Out-Null
+
+# The Python interpreter for the local http server (the install e2e's pattern).
+$py = if (Get-Command python3 -ErrorAction SilentlyContinue) { 'python3' } else { 'python' }
+
+$stableVersion = '9.9.9'
+$betaVersion = '9.9.9-beta.1'
+$platform = 'win32-x64'
+
+# The stub artifact the beta release prefix serves: a tarball whose payload
+# is a placeholder exe (the install only checks the payload exists).
+$payload = Join-Path $scratch 'payload'
+New-Item -ItemType Directory -Path $payload | Out-Null
+Set-Content -LiteralPath (Join-Path $payload 'prime-agent.exe') -Value 'stub payload for the channel-fallback regression test'
+$artifactFile = "prime-agent-$betaVersion-$platform.tar.gz"
+$artifact = Join-Path $scratch $artifactFile
+& tar -czf $artifact -C $payload prime-agent.exe
+if ($LASTEXITCODE -ne 0) { throw 'the stub artifact build failed (tar)' }
+$artifactSha = (Get-FileHash -LiteralPath $artifact -Algorithm SHA256).Hash.ToLower()
+
+# The local channel: the stable pointer + manifest WITHOUT a win32-x64 row
+# (the real stable channel's shape while Windows rides the beta channel
+# only), the beta pointer + manifest WITH the row, the versioned release
+# prefix with the artifact + its sums.
+$channel = Join-Path $scratch 'channel'
+$releaseDir = Join-Path $channel "releases\v$betaVersion"
+New-Item -ItemType Directory -Path $releaseDir -Force | Out-Null
+Move-Item -LiteralPath $artifact -Destination $releaseDir
+Set-Content -LiteralPath (Join-Path $releaseDir 'SHA256SUMS') -Value "$artifactSha $artifactFile"
+Set-Content -LiteralPath (Join-Path $channel 'stable') -Value $stableVersion -NoNewline
+Set-Content -LiteralPath (Join-Path $channel 'latest.json') -Value ('{"version": "v' + $stableVersion + '", "binaries": [], "binaries_v2": []}')
+Set-Content -LiteralPath (Join-Path $channel 'beta') -Value $betaVersion -NoNewline
+$betaRow = '{"platform": "' + $platform + '", "file": "' + $artifactFile + '", "sha256": "' + $artifactSha + '"}'
+Set-Content -LiteralPath (Join-Path $channel 'beta.json') -Value ('{"version": "v' + $betaVersion + '", "binaries": [' + $betaRow + '], "binaries_v2": [' + $betaRow + ']}')
+
+# One install run under a given channel knob, with the transcript captured.
+# It dials the channel server's $baseUrl, which the try block below learns
+# from the server itself.
+function Invoke-Installer {
+ param([string]$ChannelKnob, [string]$Prefix)
+ Remove-Item -Path 'Env:PRIME_AGENT_DOWNLOAD_BASE_URL', 'Env:PRIME_AGENT_RELEASE_CHANNEL', 'Env:PRIME_AGENT_RUST_PREFIX', 'Env:PRIME_AGENT_ALLOW_HTTP', 'Env:PRIME_AGENT_VERSION' -ErrorAction SilentlyContinue
+ $env:PRIME_AGENT_DOWNLOAD_BASE_URL = $baseUrl
+ $env:PRIME_AGENT_ALLOW_HTTP = '1'
+ $env:PRIME_AGENT_RUST_PREFIX = $Prefix
+ if ($ChannelKnob) { $env:PRIME_AGENT_RELEASE_CHANNEL = $ChannelKnob }
+ $lines = @(& pwsh -NoProfile -File (Join-Path $repo 'install.ps1') 2>&1 | ForEach-Object { "$_" })
+ return [pscustomobject]@{ Lines = $lines; Exit = $LASTEXITCODE }
+}
+
+# The server picks and holds its own port (http.server on port 0: the OS
+# hands the port out atomically, so no other process can claim it) and
+# announces it on stdout; -u flushes the announcement immediately, and the
+# test reads it back from the log.
+$serverLog = Join-Path $scratch 'channel-server.log'
+$server = Start-Process -FilePath $py -ArgumentList '-u','-m','http.server','0','--bind','127.0.0.1','--directory',$channel -PassThru -WindowStyle Hidden -RedirectStandardOutput $serverLog
+try {
+ # The port the server itself announced, then readiness is it answering
+ # a request for this test's own channel (beta.json): bounded deadlines,
+ # and a dead child fails fast instead of hanging the installer.
+ $deadline = (Get-Date).AddSeconds(30)
+ $port = $null
+ while ($null -eq $port) {
+ if ($server.HasExited) { throw "the local channel server exited early" }
+ if ((Get-Date) -gt $deadline) { throw "the local channel server did not announce its port within 30s" }
+ $announced = Select-String -LiteralPath $serverLog -Pattern 'port (\d+)' -ErrorAction SilentlyContinue | Select-Object -First 1
+ if ($announced) { $port = [int]$announced.Matches[0].Groups[1].Value }
+ if ($null -eq $port) { Start-Sleep -Milliseconds 100 }
+ }
+ $baseUrl = "http://127.0.0.1:$port"
+ $ready = $false
+ while (-not $ready) {
+ if ($server.HasExited) { throw "the local channel server exited early (port $port)" }
+ if ((Get-Date) -gt $deadline) { throw "the local channel server did not answer on $baseUrl within 30s" }
+ try {
+ $probe = Invoke-WebRequest -Uri "$baseUrl/beta.json" -TimeoutSec 2
+ if ($probe.StatusCode -eq 200) { $ready = $true }
+ } catch {
+ Start-Sleep -Milliseconds 100
+ }
+ }
+
+ # Case 1: the default channel falls back to beta and installs.
+ $prefixA = Join-Path $scratch 'prefix-a'
+ New-Item -ItemType Directory -Path $prefixA | Out-Null
+ $runA = Invoke-Installer -Channel $null -Prefix $prefixA
+ if ($runA.Exit -ne 0) {
+ $runA.Lines | Write-Host
+ throw "the default-channel install failed (exit $($runA.Exit))"
+ }
+ $transcriptA = $runA.Lines -join [Environment]::NewLine
+ if ($transcriptA -notmatch [regex]::Escape("stable does not ship Windows builds yet; installing from the beta channel")) {
+ throw 'the fallback notice is missing from the default-channel transcript'
+ }
+ if ($transcriptA -notmatch [regex]::Escape("installing prime-agent $betaVersion from the beta channel ($platform)")) {
+ throw 'the default-channel install did not resolve the beta channel'
+ }
+ $markerPath = Join-Path $prefixA 'share\prime-agent\.prime-agent-install'
+ if (-not (Test-Path $markerPath -PathType Leaf)) { throw "the install marker is missing: $markerPath" }
+ $marker = Get-Content -LiteralPath $markerPath -Raw
+ if ($marker -ne "install-rust.sh channel beta`nversion $betaVersion") { throw "the install marker says '$marker' instead of the beta channel" }
+ if (-not (Test-Path (Join-Path $prefixA 'share\prime-agent\prime-agent.exe') -PathType Leaf)) { throw 'the beta payload is missing from the default-channel install' }
+
+ # Case 2: an explicitly requested channel refuses with the beta route.
+ $prefixB = Join-Path $scratch 'prefix-b'
+ New-Item -ItemType Directory -Path $prefixB | Out-Null
+ $runB = Invoke-Installer -Channel 'stable' -Prefix $prefixB
+ if ($runB.Exit -eq 0) {
+ $runB.Lines | Write-Host
+ throw 'the explicitly requested stable channel must refuse (no win32-x64 row)'
+ }
+ $transcriptB = $runB.Lines -join [Environment]::NewLine
+ if ($transcriptB -notmatch [regex]::Escape('the explicitly requested stable channel ships no win32-x64 build yet')) {
+ throw 'the explicit-channel refusal is missing its headline'
+ }
+ if ($transcriptB -notmatch [regex]::Escape('$env:PRIME_AGENT_RELEASE_CHANNEL = ''beta''; irm https://raw.githubusercontent.com/PrimeIntellect-ai/prime-agent/main/install.ps1 | iex')) {
+ throw 'the explicit-channel refusal does not spell out the beta one-liner'
+ }
+
+ Write-Host "WIN_CHANNEL_FALLBACK default->beta=$betaVersion notice+marker verified; explicit-stable refused with the beta route"
+} finally {
+ Stop-Process -Id $server.Id -Force -ErrorAction SilentlyContinue
+ Remove-Item -Recurse -Force $scratch -ErrorAction SilentlyContinue
+}