The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
Windows code signing
Windows files the Desktop and CLI releases publish are Authenticode-signed through Azure Artifact Signing (formerly Trusted Signing), as AUTONOMOUS INC. Signing removes the SmartScreen "Windows protected your PC" prompt from a signed publisher's installer as reputation builds, lets Smart App Control run the app, and gives antivirus a publisher to trust.
Signing is off until the repository variable WINDOWS_SIGNING is required. Until then the signing jobs are skipped
and Windows ships unsigned, exactly as before this change.
What is signed
| Release | Job | Files |
|---|---|---|
Desktop (release-desktop.yml) |
sign-windows |
every .exe and .dll in Harness-windows-x64.zip and Harness-windows-arm64.zip (Harness.exe, harness-desktop.exe, harness_pipe_io.dll, Flutter's and the plugins' DLLs), then app/<version>/harness-desktop.cat, a catalog of every file in the version folder, and harness-install.exe |
CLI (release.yml) |
pty-sign |
harness-pty.exe, harness-launch.exe, harness.exe, harness-serial.exe for x64 and arm64 |
A file that already carries a valid signature keeps it: Microsoft's conpty.dll and OpenConsole.exe are not
re-signed. A file whose signature is broken fails the job.
How it works
build-windows (x64) ─┐ ┌─> upload-windows ─> publish
build-windows (arm64) ─┴─> sign-windows (x64 only) ─┘
pty-build (x64, arm64) ──> pty-sign (x64 only) ──────> windows-staging
- One x64 job per release. The Artifact Signing action does not run on Windows Arm runners. Authenticode signing does not depend on the CPU, so the x64 job signs the arm64 files too.
.github/actions/windows-signingdoes the work:- List every
.exeand.dllwithout a signature. - Sign in to Azure with the job's GitHub OIDC token (
azure/login@v3). There is no client secret. - Sign with
azure/artifact-signing-action@v2, using SHA-256 and an RFC 3161 timestamp fromtimestamp.acs.microsoft.com. Artifact Signing certificates last about three days, so the timestamp is what keeps a signature valid after that. - Verify every
.exeand.dllwithGet-AuthenticodeSignature. Each needs status Valid and a timestamp, and each one we signed must nameWINDOWS_SIGNING_PUBLISHER. The check uses the publisher name, not a thumbprint, because the certificate changes every few days.
- List every
- The Desktop catalog.
data/app.so(the Dart code),icudtl.datandflutter_assets/cannot carry an Authenticode signature, so after the programs are signedNew-FileCatalog -CatalogVersion 2.0lists every file ofapp/<version>/by hash inharness-desktop.cat, a second pass of the action signs it, andTest-FileCatalogmust say Valid. The updater refuses a version folder without it (desktop/lib/update/update_signature.dart). - Desktop zips are opened, signed and written again with the entries
package-windows.ps1writes, under the same artifact names (overwrite: true).upload-windowsandcheck-windows-zip.pyare unchanged. The manifest's sha256 is the hash of the signed bytes. - Gate.
upload-windowsandwindows-stagingaccept a skipped signing job only whileWINDOWS_SIGNINGis notrequired. Once it is, a failed or skipped signature stops the Windows publish. Nothing falls back to unsigned. - Candidate reuse. While signing is required,
desktop-release-candidate.pyrefuses a prepared candidate without a successfulsign-windowsjob. A candidate built before signing was turned on is rebuilt, not shipped unsigned. - PR CI is unchanged. Signing runs only in the release workflows.
Setup
1. Azure (owner, once)
Identity validation is done: AUTONOMOUS INC., Public Trust, United States, valid until 29 January 2029. Renew it before then in the portal (Artifact Signing account → Identity validations → Renew).
The remaining steps wait for the organisation's permission grant:
Artifact Signing account. Create one in the subscription and note its name and region. The endpoint is regional, e.g.
https://eus.codesigning.azure.net/for East US.Certificate profile. In the account, create a Public Trust profile from the AUTONOMOUS INC. identity validation. Note its name.
App registration. In Microsoft Entra ID → App registrations, create e.g.
openharness-windows-signing. Note its client ID and the tenant ID. Do not create a client secret.Federated credential. On that app → Certificates & secrets → Federated credentials → Add:
- scenario: GitHub Actions deploying Azure resources
- organization and repository: this repository
- scenario: Other issuer, issuer
https://token.actions.githubusercontent.com, audienceapi://AzureADTokenExchange - subject:
repo:autonomous-ai@98006261/openharness@1322671404:environment:release
This repository uses GitHub's immutable OIDC subject (
gh api repos/autonomous-ai/openharness/actions/oidc/customization/subshowsuse_immutable_subject: true), which names the org and repository by ID too. The subject the "GitHub Actions" scenario writes,repo:autonomous-ai/openharness:environment:release, never matches, andazure/loginfails withAADSTS700213: No matching federated identity record. Only jobs in that environment can sign, and the environment's own rules decide which branches and tags those are.Role. On the certificate profile (not the account or the subscription) → Access control (IAM), assign Artifact Signing Certificate Profile Signer to the app registration.
2. GitHub (repository admin)
Environment. The signing jobs run in the existing
releaseenvironment. Add these to it as environment variables (Settings → Environments →release). They are identifiers, not secrets:Variable Value AZURE_CLIENT_IDthe app registration's client ID AZURE_TENANT_IDthe tenant ID AZURE_SUBSCRIPTION_IDthe subscription holding the signing account SIGNING_ENDPOINTthe account's regional endpoint SIGNING_ACCOUNTthe account name SIGNING_PROFILEthe certificate profile name WINDOWS_SIGNING_PUBLISHERoptional: the certificate's common name, AUTONOMOUS INC.when unsetDeployment branches and tags.
releaseallows branchmainand tagsv*, which coversv*_desktopandv*_clitag releases and runs dispatched frommain. A Desktop candidate prepared from a PR branch (make release-desktop ARGS="--prepare") is refused by the environment while signing is required: itssign-windowsfails and the candidate is not made. Either prepare candidates frommainafter the merge, or add a branch pattern for candidate branches to the environment.Do not add required reviewers. A signing job that waits for approval holds the release run.
Switch. Settings → Secrets and variables → Actions → Variables (repository, not environment):
WINDOWS_SIGNING=required. It has to be a repository variable because the jobs'if:reads it before any environment loads. Set it only after the first test below passes.
First run and rollout
- Lint. Run
actionlint .github/workflows/release.yml .github/workflows/release-desktop.yml. PR CI'splanjob lints neither release workflow. - Desktop candidate. Set
WINDOWS_SIGNING=required, then frommainrunmake release-desktop ARGS="--prepare"(or Actions → Release desktop → Run workflow withprepare_only: true). This builds, signs and verifies without publishing to users. Check thatsign-windowslists each file, that its summary names AUTONOMOUS INC., and thatupload-windowspassescheck-windows-zip.py. - CLI dry run. Run Actions → Release → Run workflow with the
metadata-test.jsonpath.pty-signsigns, andwindows-stagingpublishes toharness/staging-dry-run. - On a real PC (Windows 11, Smart App Control on if possible), download the candidate's or staging installer in
Edge:
- File → Properties → Digital Signatures shows AUTONOMOUS INC. with a timestamp.
Get-AuthenticodeSignature harness-install.exereports Valid.- Smart App Control lets the installer and app run.
- SmartScreen shows the publisher. A new publisher can still get one prompt until reputation builds; record what you see.
- Docs. Once a signed release is out, update the copy that says Windows is unsigned:
- the
note:indocs/superpowers/specs/2026-10-19-windows-installer-design.md(around line 258) and the installer UI text it describes - the SmartScreen and Smart App Control rows in that spec and in
2026-10-18-windows-desktop-design.md - the antivirus note in
2026-10-16-windows-native-cli-design.md
- the
Turning it off. Set WINDOWS_SIGNING to anything other than required, or delete it. Releases then ship
unsigned again. Files already published stay validly signed, because each signature is timestamped.
Design
- Growth: N/A. Nothing is stored. The Azure account logs each signing request; Azure retains those logs.
- Concurrency: N/A. Each release signs its own artifacts in its own job.
- Read cost: N/A.
- Scale: a Desktop release signs about 20 to 40 files and a CLI release 8. The Basic plan includes 5,000
signatures a month, about 100 releases. The first warning is the Azure quota on the account's metrics page, or a
429in the signing step. - Compatibility: Windows does not care whether a file is signed. The updater and
install.ps1compare sha256 from the manifest, which is computed after signing. - Migration and rollback: see Turning it off. Prepared unsigned candidates are rebuilt automatically.
- Audience: Azure enforces it. Only the
releaseenvironment's OIDC subject has the Signer role, and only on one certificate profile. - Identity: a dedicated app registration with a federated credential. No person's login and no long-lived secret.
- Failure: a signing or verification failure fails the job, and with signing required that stops the Windows publish. Nothing ships unsigned silently.
- Platforms: Windows x64 and arm64, both signed on an x64 runner. macOS signing (
macos-signing) is unchanged.
Not covered yet
harness-install.exedoes not check the publisher of the zip it downloads; it relies on sha256 from the manifest. The Desktop updater does (#4435): it installs a version only when it is signed like the running app.windows-desktop.yml's staging release mode builds unsigned staging packages. Add the same signing job there if staging E2E should cover signed files.- The Windows Node runtime (
release-node-runtime-windows.yml) republishes nodejs.org'snode.exe, which the OpenJS Foundation already signs.