This repo uses GitVersion + CI for release versioning. The canonical release
flow is tag-driven: merge to main, tag main, and let GitHub Actions
build/sign/publish release artifacts.
CI computes GitVersion and stable-correction metadata in the independent
metadata job. On main and tags, x64 and ARM64 publish jobs start from that
metadata in parallel with tests and E2E, and the stable CI Gate requires all
selected lanes before a tag can publish. Pull requests do not produce release
artifacts unless packaging, build, installer, release, workflow, or classifier
infrastructure changes. Those fail-closed pull requests run the x64 publish
smoke only; ARM64 portable publish remains required on main and tags.
When either release-build lane is selected, CI also builds both architectures
of Dev-signed and unsigned Store MSIX workflow artifacts. CI Gate requires
that MSIX job to succeed. Every tag release also attaches the signed Dev MSIX
packages with their matching public certificates, provenance metadata, and
installation instructions. Unsigned Store packages stay in Actions for manual
Partner Center submission.
Keep Companion development and compatibility fixes on one branch. There is no
separate release/extended-stable branch to synchronize. Native development
defaults to npm latest; -GatewayChannel Packaged on
scripts\Build-NativeGatewayFromSource.ps1 or run-app-local.ps1 selects the latest
published openclaw/openclaw-windows-packaging release while retaining MSIX isolation.
Use -PackagingRelease <tag> to select a specific native shipping baseline.
Native Packaged reads the actual Gateway identity from the digest-verified released
MSIX and reuses its application bytes, with a development launcher rebuilt from
the exact packaging release commit. Do not infer the payload version from the
MSIX tag or moving release-policy.json: packaging may ship an older Gateway
under a newer MSIX version. GitHub publication does not establish Store rollout
availability.
WSL setup already follows npm latest, so its CI does not duplicate tests against
the native packaging baseline. CI resolves npm Latest once per workflow and runs
each selected setup/connect, revocation and network recovery job once against
that exact version. Each job's gateway-release.json artifact records the npm
selector, version, integrity and tarball URL. WSL CI does not download a packaging
MSIX or accept a packaging_release input.
Native Latest/Packaged runtime CI is still missing. Unit/helper and upstream packaging checks do not prove real isolated-session Gateway startup, pairing or recovery. That coverage requires a capability-qualified Windows client host and dedicated native runtime jobs, not a second WSL npm version. See the development/CI matrix.
Store Gateway packaging and release policy remain
owned by openclaw/openclaw-windows-packaging; these development switches neither
replace the installed Store package nor change WSL setup's npm-latest default.
Issue #1374 is delivered in two PRs: the preservation/startup foundation, then
the complete migration experience and release enablement. There is no planned
third PR. The Store product ID is 9NFPR3BGDRR5. The selected first supported
Inno release is v2026.9.5, the planned next patch after v2026.9.4, provided
both PRs ship together. The fixed source floor is pinned to 2026.9.5.0.
MigrationProductionEnabled is checked in as true so the coordinated release
and its CI artifacts carry migration; publication stays gated on the tag-time
acceptance listed under Coordinated production release
below. A listing ID is not evidence that a Store-distributed
package has passed migration acceptance.
MigrationPreparation.Prepare is the non-UI inventory API used after explicit
consent and verified source shutdown. It inventories state without moving the WSL gateway or
Local AI payload. Its protected intent is stored under
%APPDATA%\OpenClawTray\store-migration\intent.dpapi. Repeating preparation with
unchanged state reuses the unexpired intent. Intent expires after 30 days; only
new consent may renew it. Corrupt records require explicit recovery rather than
silent replacement. The inventory includes saved Gateway identity directories and
the credential-free gateways\native-setup-draft.json recovery descriptor; other
unexpected files in that directory fail closed. Atomic-write temporary siblings
for that descriptor are non-state and ignored only when their names contain the
expected 32-digit lowercase hexadecimal identifier. Preparation is serialized and writes
via a flushed sibling temporary file followed by atomic rename.
completed.dpapi is a separate receipt, written only after exclusive source
ownership, a fresh strict inventory matching the protected intent, and canonical
operator credential resolution for the active saved gateway. No active gateway
or unresolved credential fails closed without a receipt. The atomic writer never
replaces an existing receipt. Completed-receipt reads are independent of the
current wall clock: neither delayed removal nor a backward clock correction may
re-enable destructive cleanup. New records still reject future creation times,
and intent expiry and renewal checks remain unchanged. Cryptographic, identity,
path, and structural validation still apply to every read. Finalization after verified
Inno removal owns receipt and intent cleanup. A Store preview finalizer rechecks
the exact source registration and then verifies the canonical source executable,
uninstaller, process image, and mutex have disappeared. It observes the mutex
without acquiring it. Process inspection uses limited-query image access across
all sessions; unrelated paths, proven other-user candidates without an image,
and exited processes do not block. Unresolved possible source processes still
fail closed. The finalizer serializes with prepare.lock, rereads the
DPAPI completion receipt under that lock, and recaptures the bounded migration
inventory before applying the receipt's saved auto-start preference through the
packaged startup API. It deletes explicit consent, intent, then the same validated completion
receipt, so a crash after intent deletion retries from the retained receipt. It
fails closed on source inspection, receipt, inventory, startup-preference, or
cleanup failure and leaves the receipt for restart recovery. It never starts
runtime services or invokes uninstall.
Records use a versioned binary envelope protected by current-user DPAPI. They bind the migration ID, source version, architecture, Windows SID, canonical install/roaming/local directories, target Store identity, state fingerprint, startup preference, timestamps, and record kind. Intent contains inventory metadata; completion additionally requires the validated target version. The migration directory has a protected ACL for the current user, SYSTEM, and Administrators. This is a same-user boundary, not an authenticity guarantee against a malicious process already running as that user.
MigrationRecordCodec.cs is deliberately C# 5/.NET Framework compatible:
the same parser and validation policy runs in the app and in Windows PowerShell
5.1 during uninstall. Inno ships the source and Test-InnoMigration.ps1, waits
for the read-only check to exit, and does not load the tray executable for
uninstall. The check returns 10 for validated completion, 0 only when no receipt
is present, and 2 when a receipt exists but cannot be validated or the check
could not run. A present-but-unverifiable receipt (DPAPI failure, schema drift
from the frozen codec, or binding mismatch) preserves state rather than
guessing, so it never authorizes destructive cleanup. The check also bounds
itself with a watchdog so a stalled Add-Type cannot hang uninstall.
With valid completion, normal Inno startup shows finish-migration guidance
instead of starting services. The guidance keeps Inno's installer mutex held;
dismissing it exits the app before the user uninstalls. Interactive and silent Inno uninstall skip gateway
cleanup and generated-state deletion, removing only the Inno payload and its
registrations. Uninstall-LocalGateway.ps1 independently rechecks completion
before destructive work and propagates preservation as exit 10, not cleanup
success. Without valid completion, the existing interactive/silent choices
remain unchanged. Explicit --uninstall --confirm-destructive remains a
complete-removal operation and intentionally does not honor migration receipts.
Inno acquires a read-only, read-shared handle on store-migration\prepare.lock
before its normal startup receipt check and retains it until process exit, including
failed startup or shutdown. The handle is deliberately not released by managed
shutdown because a failed service disposal could leave state writers alive.
Dev, packaged, and validated browse-only fixture runs do not take this Inno
runtime lease; other isolated profiles use their resolved data directory.
Uninstall also acquires a read-only, read-shared handle before effects and retains
it through payload/registration removal.
The cleanup script joins that lock (and also locks when invoked independently)
before checking the receipt, retaining its handle until cleanup exits. These
handles exclude Store's exclusive preparation/completion/finalization handle.
Only a lock held by an in-progress migration stops uninstall before effects. Any
other unavailable lock means migration state is merely unreadable, so uninstall
continues and suppresses destructive gateway cleanup rather than trapping the user
in an app they cannot remove. Neither path permits an unlocked fallback that would
allow destructive cleanup. Completion re-detects the exact source only after
acquiring the lock,
so an uninstall-first run cannot authorize a receipt from stale source evidence.
Preparation likewise re-detects source evidence under the exclusive file lock.
Both preparation and completion inspect the exact source image across all Windows
sessions under that lock, using the same fail-closed process policy as finalization.
Running sources and busy locks return the close-Inno/Retry decision; uncertain
process inspection blocks migration without publishing a record.
Explicit consent is allowed while Inno holds its runtime reader: consent reads
and grants take a read-shared prepare.lock handle, which still excludes Store's
exclusive preparation, completion, and finalization. Grants also take an exclusive
consent.lock to serialize writers across sessions. A read never creates either
lock. A durable consent reader can finish while another writer is waiting, and
atomic replacement refuses to overwrite a read-locked record. Consent alone
never permits state adoption or preservation-mode uninstall. Finalization removes
the consent writer lock before deleting consent, intent, and completion, keeping
the completion receipt last.
The file handle, not the session-local single-instance mutex, provides continuous cross-session exclusion for participating Inno releases. Process inspection is a compatibility backstop for already-running older sources, not a lease preventing an older binary from starting after the scan. Production's minimum source version must therefore identify a verified release containing the lifetime-lock safeguard. Do not enable migration for older nonparticipating releases.
Before rollout, prove exact signed x64 and ARM64 packages, storage/DPAPI access, restart recovery, current-head guidance, and manual uninstall preservation. Passing unit or PowerShell contract tests is not signed-package migration proof.
src\OpenClaw.Tray.WinUI\Migration.Build.props owns the common Inno and Store
build contract. The tray project imports it for both x64 and ARM64 publishing,
including CI's installer and Store package payloads:
| Property | Checked-in value | Shipping requirement |
|---|---|---|
MigrationStoreProductId |
9NFPR3BGDRR5 |
Verify the listing and installed production package identity. |
MigrationMinimumSourceVersion |
2026.9.5.0 |
Verify that the selected first stable Inno release contains all preservation, lifetime-lock, and startup safeguards. |
MigrationProductionEnabled |
true |
Enabled for the coordinated 2026.9.5 release. Set to false to ship a release without migration. |
Production builds emit PRODUCTION_MIGRATION and protected-flow configuration
metadata only for non-Dev Release builds targeting win-x64 or win-arm64.
Enabling production without a valid, nonzero three- or four-part numeric source
floor fails the build. Debug and Dev builds remain outside this production gate;
Debug previews require their separate explicit flags. There is no runtime or
environment-variable activation switch.
The same coordinated release can introduce the safeguards and the full migration flow. A separate preliminary Inno release is not required. Users on older Inno versions must update Inno first, then migrate: Store installation cannot repair an older uninstaller or give an older running binary the lifetime lock.
The minimum is the fixed first supported Inno version, not the current target app version, GitVersion output, or reserved MSIX package version. Do not raise it on each subsequent release. If the first release changes before shipping, update the single pinned value and repeat acceptance with those exact artifacts.
Before tagging the coordinated release or claiming issue #1374 complete:
- Verify the selected
v2026.9.5release contains both PRs and make that supported Inno update available to existing users, with update-first guidance for older sources. If the release number or contents change, revise the pin before shipping. - Prove exact production identity, Store listing handoff, DPAPI/storage access, and signed x64 and ARM64 packages through the real distribution path.
- Exercise fresh consent, running-Inno graceful shutdown, manual close/Retry, restart recovery, older-source rejection, and ordinary non-migration startup.
- Verify normal interactive and silent Inno removal preserves the completed migration, while explicit full cleanup retains its separate destructive contract.
- Verify saved gateway credentials, a real WSL or remote gateway connection, Local AI state, and startup preference survive; Store services start only after exact source removal and finalization.
- Collect current UI evidence for longer consent, light/dark themes, compact windows, scaling, keyboard navigation, and screen-reader behavior. Unit tests, fixture screenshots, and locally test-signed packages do not replace missing signed-package, ARM64, accessibility, or gateway continuity proof.
These are release-acceptance gates, not merge-time gates. The switch is checked in as true
so the coordinated release and its CI artifacts carry migration, but a tag must not
be published until each item above is satisfied against that tag's real artifacts.
The controlled alpha-promotion path below may reserve an immutable tag to build
those artifacts, but cannot publish the stable GitHub release until acceptance.
If acceptance fails before the Store package is published, set
MigrationProductionEnabled to false and retag rather than shipping an unverified
launch gate. A synthetic source floor supplied for disposable package testing is not
approval of a production release version.
The switch is a pre-publication gate, not a recall. Once a Store package carrying
PRODUCTION_MIGRATION is published, the floor and the entire flow are compiled into
that package: a later Inno release built with the switch off cannot disable migration
for users who already have the Store build, and that Inno release still sits above the
pinned floor. Turning the switch off only prevents new migration-capable Store
builds. To stop migrations already reaching users, publish a corrected Store package.
Two things keep the Store app from starting. A handoff holding a completion receipt
keeps it from starting because that state has data that must not be abandoned, and the
receipt decides this rather than the state name: a receipt still protects the handoff
when the source looks unsupported, when the recorded source version no longer matches,
or when the record cannot be decoded. Separately, a previous app that is positively
detected as installed keeps the Store app inactive even with no receipt, because issue
#1374 permits only one active production client. That block requires payload evidence,
not just an uninstall registration, so an interrupted uninstall that leaves an orphan
registry key cannot strand the user without a working client. The two blocks differ in
how long they last, and the difference matters when supporting a user. The receipt block
is durable: it records that data has already moved, so a later pass that fails or cannot
read the record does not release it. The installed-source block is only ever as good as
the pass that measured it, so it is recomputed every time and never carried forward.
Removing the previous app is precisely how a user ends that block, and a stale copy of it
would keep the Store app closed after the previous app was already gone. The remaining
unhappy paths, a failed inspection or a record needing recovery, inform the user and then
continue to normal startup, because refusing to launch cannot repair either one.
Still confirm before the tag that the released Inno installer registers
DisplayVersion 2026.9.5 and DisplayName OpenClaw Companion version 2026.9.5.
Both are refused, and each produces a different message, so check for the right one.
An alpha or other unsupported prerelease suffix is a version refusal: that user is told
to update the previous app to a supported version first. The repository's numeric
stable-correction form, such as 2026.9.8-1, is accepted and ordered after its
unsuffixed base; its executable file version remains the base numeric version
(2026.9.8.0) while its product version must identify the exact correction.
Build properties remain numeric, so pin a correction as X.Y.Z.N when a correction
must be the minimum source (for example, 2026.9.8.1 for 2026.9.8-1). A mismatched
name is an unsupported installation: that user is told migration is unavailable.
Refused sources are not offered migration, so the registered values still have to be exact.
Neither standard MSIX artifact can exercise migration. The unsigned Store package is a submission asset and cannot be installed, and the Dev package is refused by the Store migration guard because its identity is not the production one.
CI therefore also publishes openclaw-msix-dev-migration-test-<arch> from
scripts\Export-MigrationTestMsix.ps1: the production-identity Store package,
test-signed with a disposable certificate whose subject matches the production
publisher. "Dev" in the artifact name means for developers; the package identity
is production.
That identity is what makes it useful and what makes it dangerous:
- It shares a package family name with the Store release, so it is not side-by-side. Uninstall the Store build before installing it.
- Migration runs against real data directories. The Store guard rejects data path redirection, so it cannot be aimed at a scratch profile.
- With an Inno installation present, it will adopt and then uninstall it.
Use a disposable machine or VM. The exporter refuses to sign an already-signed package and refuses any package built without migration enabled, so the artifact cannot silently ship disabled. It stays workflow-only and must never be published.
The Store-side preview hosts a dedicated WinUI migration window before normal
services start. Release non-Dev builds now ship this experience by default;
Debug and Dev builds do not. Do not enable migration by choosing the current app
version as a placeholder for a verified safeguard-containing Inno release.
An explicit test build may set StoreMigrationPreview=true and
StoreMigrationPreviewMinimumSourceVersion to a three- or four-part numeric
test source version. This is accepted only for Debug MSIX builds with the
production identity; Release, unpackaged, and Dev-identity preview builds
fail the build. Sign and run these experimental packages only in a disposable
Windows VM. They must not be distributed.
dotnet publish .\src\OpenClaw.Tray.WinUI\OpenClaw.Tray.WinUI.csproj `
-c Debug -r win-x64 --self-contained -m:1 `
-p:PackageMsix=true -p:DevBuild=false -p:AppxPackageSigningEnabled=false `
-p:StoreMigrationPreview=true `
-p:StoreMigrationPreviewMinimumSourceVersion=<verified-test-source-version>The optional unpackaged Inno handoff is independently gated:
dotnet publish .\src\OpenClaw.Tray.WinUI\OpenClaw.Tray.WinUI.csproj `
-c Debug -r win-x64 --self-contained -m:1 `
-p:PackageMsix=false -p:DevBuild=false -p:InnoMigrationPreview=true `
-p:MigrationPreviewStoreProductId=<explicit-12-character-Store-product-ID>Use that payload only in a disposable, exact current-user Inno fixture.
Release, packaged, and Dev-identity Inno previews fail the build. No preview
product ID is supplied by default. Without one, Settings hides Install Store version
and migrate. The ID accepts only 12 uppercase ASCII letters/digits and opens
ms-windows-store://pdp/?ProductId=...; do not substitute a guessed listing.
The shutdown receiver can still be exercised without a Store listing.
The Settings action confirms explicit consent before saving consent.dpapi
and opening the listing. This is a distinct consent record in the shared
current-user DPAPI contract, not an inventory intent. It binds the exact
source version, user, architecture, canonical paths and target package identity,
expires after 30 days, and rejects a future creation time. Missing, expired,
invalid or source-mismatched consent requires Store confirmation. Operational
read failures block instead of silently consenting. Consent and completion
remain independent: consent never authorizes destructive uninstall.
Explicit confirmation does not overwrite corrupt consent. A rejected grant
enters recovery, which stays retryable: the window keeps Retry and the
Installed apps shortcut so a user who removes the previous app is noticed by
the next pass, and it offers to discard migration records that can no longer
carry the handoff. Records are judged one file at a time, so a corrupt receipt
beside a good intent costs only the receipt. Two things are discardable: a
record that does not decode, and a leftover consent or intent once the previous
app is gone and no readable receipt remains, because there is then nothing left
to migrate from. A receipt that still decodes is never deleted, and a retry
never treats an earlier confirmation as still standing. A discard that cannot
run, usually because the previous app is running and holds the migration lease,
is reported in the window rather than passing silently.
The preview:
- Reads only the exact production Inno uninstall registration, not display-name
matches. Only the default current-user installation at
%LOCALAPPDATA%\OpenClawTrayis supported. Custom, machine-wide, ambiguous, inconsistent, or unreadable installations block admission. - Requires coherent source version and executable architecture evidence. Prerelease/informational versions do not satisfy the stable version gate.
- Reads existing intent/completion records through the shared DPAPI codec. A completion receipt requires finalization before normal startup, and that holds even when the receipt cannot be decoded or read: its presence on disk proves data already moved. An orphan intent, or an unreadable record with no receipt beside it, is reported and then gets out of the way, because refusing to launch cannot repair it. Completion without Inno requires finalization, not fresh startup.
- Stops before production instance forwarding, settings, gateway/node/MCP services, updates, or startup-task reconciliation when migration is needed. All normal launch, protocol, and startup-task activations use this gate.
- Shows localized Migrate / Not now buttons unless valid explicit handoff consent already exists. An inventory intent never replaces consent. Keyboard focus defaults to Not now. Not now closes the Store window without changing source state, and leaves the Store app inactive while the source app is installed, per issue #1374. The user must migrate or remove the source app before the Store app starts normally. Unlike PR 1's native Yes/No preview, this window labels its buttons directly; it does not append a separate action legend or reinterpret Yes/No as Migrate. Before acceptance, every locale discloses protected migration records, the normal Inno startup block after successful validation, and the required manual uninstall followed by Store finalization. It explains preservation, no automatic uninstall, and the option to leave without starting migration. Retry guidance permits uninstall only after the window reports recorded completion.
- After consent, requests graceful exit through the existing current-user
activation pipe. This is a private fixed IPC message, not an
openclaw:route. Only the gated, exact Inno process accepts it after rechecking protected consent, then delegates to the canonical app shutdown coordinator. The sender bounds IPC to two seconds and checks mutex release for up to ten seconds. Unsupported, unavailable or slow receivers leave Close the previous app / Retry guidance. Sending the message alone is not proof of exit; source ownership is checked again before preparation and completion. No force-kill. - When Inno is closed, the preview acquires exclusive migration ownership,
rechecks exact source evidence, and writes a protected, DPAPI-bound inventory
intent. It then captures the inventory again, requires its fingerprint to
match the intent, and requires canonical operator credential resolution for
the active saved gateway before atomically writing a protected completion
receipt. Data is adopted in place. It does not start gateway, node, or MCP
services; provision or repair gateways; delete source state; invoke uninstall;
automatically. The receipt blocks normal Store startup and exposes Open
Installed apps. The user uninstalls Inno manually, then selects Retry or
reopens Store. Only an exact
NotInstalledresult plus absent canonical source payload/process/mutex evidence permits finalization. The finalizer does not acquire the Inno-visible mutex, serializes onprepare.lock, rereads and matches the durable completion receipt, recaptures the inventory fingerprint, applies the saved auto-start preference through the tray adapter, and clears records only after that call succeeds. Successful finalization resumes the original launch, including any pending protocol activation. Errors remain visible with Retry; state transitions are announced to accessibility clients and no percentage is invented. - Preserves normal fresh-install behavior when there is no exact Inno registration and no pending migration record.
This admission result is not an authorization to uninstall. The consent workflow reacquires exclusive ownership, revalidates source state, and writes completion only after its active-gateway credential check succeeds. Official signed-package acceptance on x64 and ARM64, local and remote gateway continuity, verification of the selected Inno release's safeguards, actual Store handoff, and production enablement remain release gates. The source floor and Store listing ID are assigned above; UI tests with fake operations are not package-boundary or real migration proof.
Use Actions > Promote alpha to stable, on main, to select a published
vX.Y.Z-alpha.N candidate. This is an additional supported release path: it
promotes an approved ancestor of main instead of including every newer commit.
The stable target is always vX.Y.Z. Arbitrary version changes, correction
promotion, and Partner Center submission are not supported by this workflow.
Start with prepare=false (the default). The read-only preview checks the exact
alpha SHA, its successful canonical release run and required jobs, ancestry,
stable ordering, and published target availability. It links the included changes since
the previous stable release and the newer main changes excluded. Preview does
not reserve tags or MSIX versions, sign packages, or publish anything.
The read-only workflow token cannot discover private draft conflicts.
Preparation checks unrelated or duplicate drafts before reserving the tag.
gh workflow run promote-alpha-release.yml `
--repo openclaw/openclaw-windows-node --ref main `
-f alpha_tag=v2026.9.5-alpha.93 -f prepare=falseBefore preparing a release, a repository administrator must create the
stable-release environment with required reviewers and administrator bypass
disabled. Restrict its deployment branches to main. For normal reviewers,
enable Prevent self-review. To let OpenClaw release managers publish without
a separate reviewer, set the only required reviewer to
openclaw/release-managers-openclaw (team ID 16590423) and disable
Prevent self-review. GitHub enforces team membership for approval; members
may approve their own run, including through their authorized release agent.
Other teams, individual reviewers, or additional reviewers cannot use this
self-review exception. Missing or weaker protection fails before any tag is
created.
The existing release-signing environment is still used for Azure OIDC signing;
it is not a substitute for this final acceptance approval.
Rerun with prepare=true to authorize reservation and building:
gh workflow run promote-alpha-release.yml `
--repo openclaw/openclaw-windows-node --ref main `
-f alpha_tag=v2026.9.5-alpha.93 -f prepare=trueThe workflow freezes two different revisions. The candidate SHA owns product source, tests, build scripts, and Inno installer inputs. The dispatch SHA on main owns release policy, validation orchestration, signing checks, MSIX allocation, and publication. The local reusable workflow reference binds CI to that same pipeline revision. No main product files are copied into the candidate tree. Incompatible historical source fails normally; do not silently patch the alpha or replace its SHA with main to make it pass.
Preparation creates a checkout-only stable tag in each candidate build/test
workspace so GitVersion resolves the stable version without project-version
overrides. These refs are never pushed and do not change versioning on main.
The full CI Gate remains mandatory. Only after protected publication approval
and artifact verification does publication create the public annotated stable
tag with immutable promotion provenance. It uses GITHUB_TOKEN, whose ref
creation does not trigger another tag-push workflow. Do not replace it with a
PAT or dispatch CI on the old candidate tag: that would execute the historical
workflow instead of the selected pipeline.
Tray UI crash diagnostics are pipeline-owned. Promotions fetch the metadata helper from the pinned dispatch SHA into a separate sparse checkout after the UI tests. The alpha checkout still owns the app and tests, even when it predates that helper. Ordinary CI uses the helper from its normal source checkout.
The existing MSIX allocator reserves a new package version for the stable tag, shared by both architectures. Promotion rechecks candidate eligibility and approval protection, then the allocator verifies the existing same-base alpha tag resolves to the exact source SHA on every allocation attempt. Its metadata records the future stable ref without requiring that public tag during preparation. Ordinary release allocations still require their exact public source tag. Neither the alpha package version nor an existing published stable release is reused. The result is the same source, not identical bytes: versions, signatures, build tools, and restored dependencies can differ. Use the recorded pipeline revision and build logs when investigating toolchain differences, and validate the newly built artifacts.
After CI, signing, and package validation, alpha-promotion-<attempt> contains the
prepared installers, portable ZIPs, signed Dev MSIX ZIPs, and promotion.json.
Unsigned Store submission packages remain separate workflow artifacts, matching
the normal release path. Dev ZIPs include their public certificates, provenance,
and installation instructions; they are not Microsoft Store-signed packages.
The manifest records source and pipeline SHAs, original alpha CI, previous
stable, preparation run/attempt, MSIX reservation, and every asset's SHA-256.
The job summary presents this manifest before the stable-release review.
Record links to the required acceptance evidence in the environment review.
For v2026.9.5, this includes the coordinated migration proof above on exact
signed x64 and ARM64 packages. A Store listing or a green CI badge is not that
proof. Do not approve a run with missing acceptance.
Publication explicitly checks !cancelled() and successful release preparation
so an intentionally skipped ancestor, such as the pull-request-only test soak,
does not suppress the approval job through GitHub's implicit success() check.
Failed preparation and cancelled runs still cannot publish.
Promotion publication uses only GITHUB_TOKEN with Contents: write. No PAT,
GitHub App key, or separate release-token secret is required by the workflow.
The approved alpha SHA and pipeline SHA are pinned in promotion.json; moving
main forward does not impose a workflow-file equality requirement. The existing
ancestry check still requires the pinned pipeline to remain on main's history.
Publication creates and verifies the annotated stable tag at the exact alpha
SHA before creating the release. The release request specifies that existing
tag and omits target_commitish, which GitHub documents as unused for existing
tags. Release notes still explicitly compare the previous stable with the alpha
SHA. Tag creation, asset uploads, and publication all use GITHUB_TOKEN, so
creating the stable tag does not trigger historical tag workflows.
The local checks prove the request shape and race handling, not GitHub's live permission decision. If GitHub rejects tag creation or release publication, stop and inspect that API failure; do not move the alpha or stable tag, switch the source to main, or mint broader credentials automatically. The token-only path with differing historical workflow files needs live Actions verification.
Approval publishes the exact prepared artifact ID, not a rebuild. Under the
shared release-publication lock, CI rechecks source tags, Latest ordering,
approval protection, and hashes, uploads to a private draft, verifies the
uploaded digest set, then marks the release stable and Latest. Release notes
compare the previous stable tag to the chosen candidate, not to current main.
promotion.json is attached permanently to the published release. This does not
modify, resubmit, or claim acceptance of the package already in Microsoft Store.
- Preview can be repeated without side effects. The initial alpha release and its successful CI evidence must remain available while promotion is pending.
- An unpublished stable tag can be reused only with identical annotation, candidate, previous stable, and pipeline provenance. Resume the original workflow run if main has advanced. A new pipeline cannot silently adopt an older reservation. Published targets are never replaced or moved.
- Failed or cancelled preparation, or rejected/cancelled approval, creates no public stable tag and does not advance subsequent main alphas. The separate MSIX package-version reservation remains consumed to preserve monotonicity.
- Once approval is granted and publication starts, the public stable tag is created immediately before draft creation and uploads. A failure or cancellation in that publication window retains the tag and any partial draft for an exact retry; main alphas can then advance. Do not remove or move a publication tag.
- Rerun failed jobs to reuse the exact prepared artifact after a partial upload. A rerun that rebuilds outputs creates a new attempt artifact and requires new approval. An existing draft bound to different bytes blocks publication; inspect and explicitly remove only that unpublished draft before retrying. Duplicate drafts for the target tag also block publication.
- If publication succeeds but final verification fails, do not rerun or replace the release. Confirm it is published, non-prerelease, and Latest, and verify every uploaded asset's size and SHA-256 against the approved manifest. Record that verification in the run's acceptance evidence before closing it.
- A newer stable publication, moved candidate, changed acceptance protection, missing/expired evidence, or mismatched artifact stops publication. Pending promotion artifacts expire after 30 days. Restart acceptance for rebuilt artifacts rather than treating an expired approval as reusable proof.
-
Start clean on current
main.git switch main git fetch origin main --prune git reset --hard origin/main git clean -fd git status --short --branch
-
Confirm the release workflow contains the intended release policy.
Select-String .\.github\workflows\ci.yml -Pattern ` "Verify Release Binary Signing Policy", ` "OpenClaw.Tray.WinUI.exe", ` "build-msix:", ` "Stage signed Dev MSIX release assets"
-
For a direct release, create a new stable, stable correction, or prerelease tag from
origin/main. For an existing published alpha, use the controlled promotion workflow above. Never move a previously published tag.# Stable: vX.Y.Z # Stable correction on the current Windows latest line: vX.Y.Z-N # Prerelease: vX.Y.Z-alpha.N $tag = "vX.Y.Z" if ((git rev-parse HEAD) -ne (git rev-parse origin/main)) { throw "HEAD is not origin/main; do not tag." } git tag -a $tag -m "OpenClaw Windows Hub $tag" git push origin $tag
-
Watch the tagged workflow.
gh run list --repo openclaw/openclaw-windows-node ` --workflow "Build and Test" ` --limit 10
-
Confirm the workflow used the exact tag SemVer. Tagged builds fail before publishing if GitVersion disagrees with the tag name.
$version = $tag -replace '^v', '' .\scripts\Get-OpenClawVersion.ps1 -Variable SemVer # Expected: $version
-
Confirm the GitHub release channel matches the tag. Stable tags should be non-prerelease releases; alpha tags should be prereleases and not latest.
gh release view $tag --repo openclaw/openclaw-windows-node ` --json tagName,isPrerelease,isLatest,url,assets
The sign-cleanup-host job also publishes the x64 and ARM64 fixed file workers
and signs only their first-party EXE/DLL files on the x64 signing runner. It
verifies their release signer before generating each payload manifest.
The portable/Inno and MSIX build jobs download those complete signed payloads
and set OpenClawSignedFileWorkerPath to the matching RID directory.
RequireSignedFileWorker=true rejects missing or unsigned input before
Companion embeds its manifest. Ordinary non-release builds still publish a
local unsigned worker.
Manifest generation explicitly launches PowerShell 7 (pwsh on the build
host's PATH), matching the signing job and cleanup-helper checks. It does
not launch Windows PowerShell 5.1 with inherited PowerShell 7 module paths,
which can prevent the Authenticode module from loading.
Do not sign or republish the worker after manifest generation: either changes the bytes checked by Companion's embedded digests. Final release signing covers the app binaries separately and verifies the already-signed worker in its manifest-addressed slot. Signed-package and native runtime proof remain separate release obligations.
Stable, stable-correction, and alpha tags use the same signed CI release pipeline:
vX.Y.Zcreates a normal release eligible to become latest.vX.Y.Z-Ncreates a stable correction release eligible to become latest. The numeric correction suffix intentionally follows the OpenClaw release convention and is not treated as a SemVer prerelease. Windows Hub release tags are their own version domain: a correction is a correction of the Windows latest release, not a mirror of any other repository's release. CI enforces that inscripts\Test-OpenClawStableCorrectionRelease.ps1, which requires the candidate to stay on the sameX.Y.Zbase line as the current Windows latest release and to carry a strictly greater numeric correction. Same, older, and different-line corrections fail closed, so GitHub's Latest release marker can never move backward. The validator also refuses a candidate that already has a published Windows release, and refuses to order against a draft, prerelease, or unpublished latest release, so a published tag can never be reused. Every numeric-suffix tag, including malformed ones such as-0and-03, is routed through the validator rather than silently classified by GitVersion.vX.Y.Z-alpha.Ncreates a prerelease that stable updater checks do not offer. Like every canonical tag, it includes signed x64/ARM64 Dev MSIX ZIPs with their matching public certificates and instructions. The pre-release is visible on GitHub's Releases page but is not promoted as Latest. The daily workflow evaluates the default branch at 2:00 PM Pacific, skips a head already represented by a published release, and defers while an unpublished non-alpha tag points at the head. After each successful alpha publication, CI removes canonical alpha release objects and assets older than 30 days so daily builds do not overwhelm the Releases page. Their Git tags remain as GitVersion history. If the new release is not yet visible through the Releases API, cleanup defers until the next alpha publication.
An authenticated Gateway on extended-stable may defer an ordinary Windows
companion update only when the official GitHub release body contains exactly
one explicit classification marker:
<!-- openclaw-update: ordinary -->permits extended-stable deferral.<!-- openclaw-update: security-critical -->keeps the update visible.
Add the applicable marker when reviewing the generated release notes. Missing, duplicated, conflicting, or malformed markers are unverified and keep the update visible. Release names and prose are not scanned for security keywords.
The validator has no dependency on another repository's release API. Run it offline against an explicit current release to preview a decision:
# Accepted: same 2026.7.1 line, correction 3 > 2
.\scripts\Test-OpenClawStableCorrectionRelease.ps1 `
-Tag v2026.7.1-3 -CurrentWindowsTag v2026.7.1-2
# Rejected: reuse of a published tag
.\scripts\Test-OpenClawStableCorrectionRelease.ps1 `
-Tag v2026.7.1-2 -CurrentWindowsTag v2026.7.1-2scripts\test-stable-correction-release-validator.ps1 runs the full accept and
reject matrix deterministically and is also enforced in CI.
The live v2026.7.1-2 annotated tag dereferences to commit f46400aa, which is
the correction-aware implementation ("Support upstream stable correction release
versions", #1266). Release run 33221425381 built and signed that release's
assets, so v2026.7.1-2 is the current correction-aware Windows latest release.
Never move, rebuild, or reuse that tag; the next correction on this line is a new
v2026.7.1-3 tag.
Clients on older unsuffixed 2026.7.1 builds predate the correction-aware
update path. They use Updatum's default parser, which drops the numeric
correction suffix before comparison, so they may need a manual transition to a
correction release. Clients already on 2026.7.1-2 are correction-aware: even
though Updatum 1.3.4's default parsing does not rank 2026.7.1-3 above
2026.7.1-2, the OpenClawReleaseVersion fallback in the update check pipeline
compares releases under OpenClaw correction ordering and discovers 2026.7.1-3.
Gateway versions are a separate domain. Managed setup resolves npm latest
independently and verifies that the protocol-v4 handshake reports the installed
package version. A Windows Hub correction release does not select a Gateway
package version; see
adr/0001-gateway-release-policy.md.
git tag -a vX.Y.Z-alpha.N -m "OpenClaw Windows Hub vX.Y.Z-alpha.N"
git push origin vX.Y.Z-alpha.NCurrent release artifacts are:
- Inno setup installers:
OpenClawCompanion-Setup-x64.exeOpenClawCompanion-Setup-arm64.exe
- Portable ZIP payloads for Updatum:
OpenClawTray-<version>-win-x64.zipOpenClawTray-<version>-win-arm64.zip
Every stable, correction, and prerelease additionally contains:
OpenClaw-Dev-x64.zipOpenClaw-Dev-arm64.zip
Each archive contains the signed Dev-identity MSIX, its matching public
certificate, msix-metadata.json, and INSTALL.txt. These packages are
development-signed for sideloading, not Microsoft Store-signed. Testers must
extract the matching architecture archive and follow its instructions,
including explicitly trusting the included public certificate.
Unsigned Store submission packages, the multi-architecture bundle, and their metadata remain Actions artifacts only. Use Store publication requests to request release-manager-approved central publication of the validated unsigned bundle from a successful release run. No production signing step is applied to those Store inputs.
Automatic central publication requests are staged behind MSSTORE_ENABLED.
The variable never bypasses central release-manager approval.
Store-signed retrieval and publication, and official lifecycle acceptance
remain release gates tracked in #1375. Submission automation and release
artifacts do not clear those rollout gates.
Store versions still end in .0. Official tagged builds now reserve distinct
package versions as described below; reruns reuse the same reservation.
See CI MSIX downloads for Dev certificate
handling, preview limitations, and installation instructions.
Application release tags and assembly versions remain GitVersion-owned.
MSIX uses X.Y.(Z * 100 + packaging revision).0 for app base X.Y.Z, with
packaging revisions 0-99 shared across alpha, stable, and correction tags on
that base. The correction suffix is not a separate encoded digit. A different
patch or year/month starts its own range. Windows' 65535 component limit still
applies, including to the last partial range.
.github/msix-version-baseline.json imports already-used versions. It marks
2026.9.400.0 used and records the workflow run, source commits, artifact IDs,
and package hashes that substantiate that migration floor. This file is
migration state, not a value to bump for each release. New 2026.9.5 releases
start at 2026.9.500.0.
The canonical ledger now contains the first live reservation for this release
line at refs/tags/msix-package/2026.9.4/401. It targets the commit behind
v2026.9.4; an identical second allocator run reused the same reservation
instead of consuming another number. Therefore the next unreserved
2026.9.4 candidate is 2026.9.402.0.
PR/main metadata jobs resolve the latest published stable Windows release from
the canonical upstream repository and call
scripts\Resolve-MsixPackageVersion.ps1 in read-only mode against that release
line and the canonical reservation ledger. While Latest is v2026.9.4, their
Store preview is 2026.9.402.0, even if GitVersion on main or the PR has moved
to a 2026.9.5 development line. This selection affects only MSIX manifests;
assemblies, EXE/ZIP artifacts, GitVersion output, and release tags are unchanged.
Only the upstream reserve-msix-version job, guarded to tagged
push/workflow_dispatch runs and scoped to contents: write, passes
-Reserve. The matrix consumes its one shared JSON result, avoiding independent
x64/ARM64 allocation. All other jobs retain their existing permissions.
Reservations live in annotated tags
refs/tags/msix-package/<app-base>/<package-counter>, targeting the source
commit and containing the allocation JSON. The allocator uses atomic ref
creation, not mutable release assets or the expiring Actions artifact store.
If another run wins the same number, it verifies the competing record and
retries. The same source release tag must always resolve to the same commit
and reservation; moving a source tag is an error.
Do not delete or force-update these records. Failed or cancelled builds keep
their reservations and must be retried with the same source tag. Alpha release
retention deletes release objects/assets, not the allocation tags. They do not
begin with v and therefore do not trigger tag-driven release builds. The
active Protect MSIX package reservations tag ruleset blocks deletion and
non-fast-forward updates under refs/tags/msix-package/**/*; preserving that
ruleset is part of the release contract.
The canonical reservation ledger is an intentional, fail-closed dependency of the release workflow. If allocation, authentication, permissions, or ledger validation fails, the tagged release stops before publishing EXE/ZIP assets. Maintainers must repair and rerun the same source tag rather than bypassing the allocator or publishing a partial release.
API, authentication, malformed-state, exhaustion, and retry-limit errors fail closed. No workflow should replace such a failure with a guessed version.
Package metadata contains msixVersionAllocation, including source version,
source commit/ref, package base, allocation kind, and reservation ref.
Preview candidates never reserve a number and can change between reruns;
they must not be treated as official Store submissions.
The release stager requires -VersionInfoPath for the exact reserved result. It
checks the app version, source commit, workflow run, reserved allocation,
package and certificate hashes, Dev identity, signature presence, version, and
both architectures' metadata before creating any release ZIPs:
.\scripts\Stage-DevMsixReleaseAssets.ps1 `
-ArtifactDirectory 'artifacts\msix-release' `
-OutputDirectory 'msix-release' `
-Version $appVersion -ExpectedSourceCommit $sourceCommit `
-ExpectedRevision $runNumber -ExpectedWorkflowRunId $runId `
-VersionInfoPath $reservedVersionInfoPathThis does not bypass CI Gate or signing approvals, move existing application tags, or automate Store submission.
After the workflow change is on the default branch, a maintainer with Actions write access can use Actions > Daily Alpha Release > Run workflow, or:
gh workflow run daily-alpha-release.yml `
--repo openclaw/openclaw-windows-node --ref mainThis is a request to release the current default branch, not the selected feature branch. It bypasses only the scheduled time-of-day check. All existing change, published-head, pending non-alpha tag, canonical GitVersion, and tag ownership checks remain active. If the head is already published, it skips; it does not replace the release, move the tag, or force a new version.
When there is an eligible new head, the workflow creates or reuses its
unpublished vX.Y.Z-alpha.N tag and dispatches Build and Test on that tag.
The full CI Gate and release-signing environment still gate publication.
The release stays a public pre-release with make_latest: false.
Existing 30-day alpha retention applies to its submission assets too.
Running Build and Test manually on a branch is still build-only. Running it on an eligible alpha tag uses the same tagged release path. No new unreviewed-branch or MSIX-only version allocator is introduced.
The 0.8 npm bridge shipped exactly wxc-exec.exe and wslcsdk.dll under
tools\mxc\x64 and tools\mxc\arm64. Inno removes those four known files,
then removes only empty known directories. It does not remove unknown files,
user settings, gateways, credentials, approvals or unrelated Node installations.
The new SDK's app-root wslcsdk.dll is required and must remain.
Portable ZIPs are also in-app Updatum payloads. Updatum 1.3.4 copies over the
destination with robocopy /E /COPY:DAT (or xcopy), not a mirror; destination-only
legacy files survive. The new unpackaged app therefore delegates idempotent
exact-file cleanup to LegacyMxcFiles after primary-instance admission. It
refuses reparse traversal and logs coarse failures. Packaged app versions are
OS-managed and are never deleted by this cleanup.
Build/publish targets remove these exact stale artifacts from incremental output,
and Store/Dev package verification and release signature classification reject
them if present. Run .\scripts\test-legacy-mxc-payload.ps1 and
.\scripts\test-msix-ci-artifacts.ps1 for synthetic fixtures. These checks do not
substitute for a real old-to-new installer/in-app update smoke.
Only OpenClaw-owned binaries should be signed by the OpenClaw release signing identity.
OpenClaw-owned binaries:
OpenClaw.Tray.WinUI.exeOpenClaw.Tray.WinUI.dllOpenClaw.Chat.dllOpenClaw.Connection.dllOpenClaw.SetupEngine.UI.dllOpenClaw.SetupEngine.dllOpenClaw.Shared.dllOpenClawTray.FunctionalUI.dllOpenClaw.GatewayCleanupHost.exeembedded insideOpenClaw.SetupEngine.dll
Third-party/runtime executables that must not be OpenClaw-signed:
plm.exewxc-wslc-daemon.execreatedump.exeRestartAgent.exeSetupEngine\RestartAgent.exe
The exact Microsoft.Mxc.Sdk 1.0.0 NuGet dependency supplies both supported RIDs
(win-x64, win-arm64). Published app roots must contain
Microsoft.Mxc.Sdk.dll, mxc_ffi.dll, wslcsdk.dll, plm.exe and
wxc-wslc-daemon.exe. Neither MXC helper may be signed with an OpenClaw
certificate. Root npm manifests, EXE discovery and tools\mxc copy targets are
retired. Actual MSIX, installer, SAC and ARM64 native proof remain separate
release gates; an x64 build is not evidence for those gates.
CI enforces this with scripts\Test-ReleaseExecutableSignatures.ps1. The
verifier inspects every shipped .exe and .dll, fails closed on unknown
executables and unknown OpenClaw-named binaries, and rejects an OpenClaw
signature on third-party/runtime binaries. When release signing is required,
every allowlisted OpenClaw binary must have a valid signature from the expected
OpenClaw release signer; a valid signature from another publisher is rejected.
CI also checks native runtime dependencies before release packaging. Both the
x64 and ARM64 portable payloads must ship vcruntime140.dll in the payload
root for the native speech stack. Both build legs source their loose VC runtime
DLLs from the Visual Studio install on the CI runner (resolved via vswhere in
the repo-root Directory.Build.targets, consumed by src\Directory.Build.targets).
This ensures the bundled CRT is new enough for onnxruntime. Local x64 builds
and test hosts use the same resolution whenever the Visual Studio install's
current redist is at least 14.38 and contains the requested architecture; the
VCRuntime.CefSharp.140 NuGet (14.29) is the warned fallback when that compatible
runtime is missing, stale, or architecture-incomplete. The release validation
script enforces a minimum VC++ runtime version floor (currently 14.38) to
prevent regressions, and the x64 verifier load-probes the native TTS stack
(onnxruntime.dll, sherpa-onnx.dll, and sherpa-onnx-c-api.dll) from the
published payload so app-local runtime mismatches are caught before release.
The release job must Authenticode-verify Microsoft's x64 and ARM64 Visual C++
Runtime redistributables before passing the
architecture-matching redistributable to Inno. The installer runs the
redistributable before launching the tray so clean or stale Windows hosts can
repair the runtime before native speech components initialize, and it
skips the post-install tray launch if the runtime installer fails.
The current Azure Artifact Signing resource is:
- Account:
openclaw - Certificate profile:
openclaw - Endpoint:
https://eus.codesigning.azure.net/ - Public trust certificate subject:
CN=OpenClaw Foundation, O=OpenClaw Foundation, L=Mill Valley, S=California, C=US
GitHub Actions authenticates with Azure through OIDC, not a stored client
secret. The release job runs in the release-signing environment and requires:
AZURE_CLIENT_IDAZURE_TENANT_IDAZURE_SUBSCRIPTION_ID
Do not add AZURE_CLIENT_SECRET back to the release workflow. The Entra app
registration should have a federated credential for:
repo:openclaw/openclaw-windows-node:environment:release-signing.
On release tags and alpha promotion builds, sign-cleanup-host first builds the
AnyCPU .NET Framework cleanup executable and signs it through the existing
protected release-signing environment. The x64, ARM64 and Store/Dev MSIX build
jobs download that same signed artifact before compiling SetupEngine.
OpenClawSignedCleanupHostPath selects those bytes instead of rebuilding the
helper through its project reference. Non-dev Release builds default to
RequireSignedCleanupHost=true and reject a missing signing input; any supplied
signing input must have a valid Authenticode signature. Debug and Dev builds
retain the unsigned project-reference path. Non-published PR release smoke and
MSIX fixture builds explicitly set RequireSignedCleanupHost=false; the same
override is available for intentional unsigned local Release testing, not
release publication.
SetupEngine verifies the input before embedding and checks the actual compiled
resource afterward for a matching hash and valid signature. The release payload
verifier also extracts that resource and requires the expected OpenClaw signer.
Signing only the outer DLL or MSIX does not sign an embedded executable. Do not
post-sign a loose helper and assume the previously embedded bytes changed.
scripts\test-cleanup-host-signing.ps1 exercises the real build with an existing
OS-signed fixture, unsigned development output, missing/unsigned signing inputs
and mismatched resource bytes, without creating certificates or changing trust.
The release workflow does not recursively sign every .exe. Instead it creates
temporary signing input directories with hardlinks to only the OpenClaw-owned
executables and DLLs from the x64 and ARM64 payloads, then runs Azure Artifact
Signing on those allowlists. Because these are NTFS hardlinks, signing the
staged file signs the real payload file.
After signing, CI verifies the actual payload directory, not the staging folder. If hardlink signing does not affect the payload, the verifier fails before release artifacts are created.
For release tags, the Build and Test workflow should run:
change-classificationwith thefullresultfast-validationsign-cleanup-hostbefore release payload compilationteste2etestsshards:setup-connect,revocation-recovery, andnetwork-recoverybuildmatrix entries shown by GitHub asbuild (win-x64)andbuild (win-arm64)CI Gaterelease
The setup-connect E2E shard contains the MXC proof tests for the gateway ->
Windows node -> system.run path and validates that the expected proof test
names appear in the TRX output. GitHub-hosted runners may report those MXC
proofs as skipped when the host is not MXC-capable; use
.\scripts\validate-mxc-e2e.ps1 for required local/self-hosted MXC merge
validation. Release tags cannot enter the release job until CI Gate
confirms classification, fast validation, tests, E2E, and release builds all
succeeded. The build-msix and build-msix-bundle jobs must also succeed
whenever release metadata is required. The release job downloads and attaches
its signed x64 and ARM64 Dev packages, public certificates, metadata, and
instructions for every canonical tag. Unsigned Store distribution stays
workflow-only.
The release job should:
- Download x64/ARM64 tray payload artifacts.
- Authenticate to Azure with OIDC in the
release-signingenvironment. - Sign only the OpenClaw-owned EXEs and DLLs in both payloads.
- Verify binary signing policy.
- Create the portable x64 and ARM64 ZIPs.
- Build Inno installers.
- Sign installers.
- Stage the validated signed Dev MSIX packages and their public-only support files into architecture-specific ZIPs.
- Create a GitHub release whose prerelease flag matches the tag, with installer and portable ZIP assets plus the signed Dev MSIX ZIPs.
After the release exists, download an installer and both portable ZIPs and verify:
$tag = "v0.6.12" # replace with the tag being verified
gh release view $tag --repo openclaw/openclaw-windows-node `
--json tagName,isPrerelease,isLatest,url,assetsExpected:
- Stable tags:
isPrereleaseisfalse. - Alpha tags:
isPrereleaseistrueandisLatestisfalse. - Installer EXEs are signed.
OpenClaw-Dev-x64.zipandOpenClaw-Dev-arm64.zipare present, and each contains the signed MSIX, matching public certificate, metadata, andINSTALL.txt.- In ZIP payload:
OpenClaw.Tray.WinUI.exeis OpenClaw-signed.- All listed OpenClaw-owned DLLs are OpenClaw-signed.
wxc-exec.exe,createdump.exe, andRestartAgent.exeare not OpenClaw-signed.
Do not move a published tag. After the fix is merged to main, create a new
tag: increment alpha.N for a prerelease, or choose the next intended stable
version.
Use these commands to inspect state:
git status --short --branch
git rev-parse HEAD
git rev-parse origin/main
$tagPrefix = "vX.Y.Z" # use the stable or prerelease version family being fixed
git ls-remote --tags origin "refs/tags/$tagPrefix*"
gh run list --repo openclaw/openclaw-windows-node `
--workflow "Build and Test" `
--limit 10For direct releases, only tag when HEAD == origin/main. An older alpha may
only receive a stable tag through the controlled promotion workflow above.
- Do not manually bump project or manifest versions for routine releases.
- Do not add csproj
<Version>release fallbacks; product versions come from GitVersion/tag history. - Release versions come from the tag (
vX.Y.ZorvX.Y.Z-alpha.N). - Untagged
masterbuilds are prerelease builds. AftervX.Y.Z-alpha.N, an untagged commit may resolve to the next alpha prerelease, for exampleX.Y.Z-alpha.(N+1). - CI computes GitVersion outputs for artifact naming, while product builds use GitVersion-backed assembly metadata.
See Store publication requests for the central publishing
boundary, required administrator cutover, manual requests from existing release
runs, automatic request activation, and recovery. This repository only sends
requests to openclaw/releases; it does not hold Store publishing authority.
Automatic requests remain off until the repository variable MSSTORE_ENABLED
is true. The stable-promotion approval, MSIX version reservations, unsigned
x64/ARM64 artifacts, and release witness remain unchanged.