Skip to content

An agentic browser harness: an AI side panel & orb in your own logged-in Chrome, Edge, Arc, Brave or even Firefox run by the agent/subscription you already use (Claude Code, Codex, Antigravity). Free, open source, no API key. Also an MCP server.

docs: the Windows app beside the macOS one — installing it in one PowerShell line or from its installer, the window tab by tab, the launcher and the PATH, updating and uninstalling, and its internals — with Windows still experimental and what one desktop has shown so far

Shahriar521c759012ff
diff --git a/README.md b/README.md
index b582338..d6c19fc 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,12 @@ npx browsentic setup
curl -fsSL https://browsentic.com/install.sh | sh
```
+**Windows** — one line in PowerShell installs [the Windows app](docs/guide/windows-app.md), which brings Node and everything else ([experimental](docs/guide/limits.md#windows-is-experimental)):
+
+```powershell
+irm https://browsentic.com/install.ps1 | iex
+```
+
Full install and setup guide, Firefox included: **[browsentic.com/docs/guide/install](https://browsentic.com/docs/guide/install/)**
## Key Capabilities
diff --git a/docs/guide/README.md b/docs/guide/README.md
index 6636f57..2b262c7 100644
--- a/docs/guide/README.md
+++ b/docs/guide/README.md
@@ -7,7 +7,7 @@ Everything you need to run Browsentic on your own machine and your own browser.
Three short steps, about five minutes in total. There is no account, no API key and no cloud
service.
-1. **[Install](install.md)** — one command, then load the extension. On a Mac, the [app](mac-app.md) does the same from a window
+1. **[Install](install.md)** — one command, then load the extension. On a Mac or on Windows, an app ([macOS](mac-app.md), [Windows](windows-app.md)) does the same from a window
2. **[Pair](pair.md)** — connect your browser with a single-use code
3. **[First run](first-run.md)** — a tour of the side panel, and your first instruction
diff --git a/docs/guide/install.md b/docs/guide/install.md
index 1fe8b78..c7ee705 100644
--- a/docs/guide/install.md
+++ b/docs/guide/install.md
@@ -14,7 +14,7 @@ AI agent you already run locally.
| --- | --- | --- |
| **Node** | 20 or newer | `node --version` |
| **Browser** | Chrome or another Chromium browser (Edge, Brave, Arc), or Firefox 140 or newer | — |
-| **System** | macOS or Linux; Windows 10 or 11 is [experimental](limits.md#windows-is-experimental). macOS also has an [app](mac-app.md) | — |
+| **System** | macOS or Linux; Windows 10 or 11 is [experimental](limits.md#windows-is-experimental). macOS and Windows also have an app ([macOS](mac-app.md), [Windows](windows-app.md)) that brings its own Node | — |
| **Agent** | One of [Claude Code](https://claude.com/claude-code), [Codex](https://developers.openai.com/codex/cli), [Antigravity](https://antigravity.google/docs/cli/install), [Mistral Vibe](https://github.com/mistralai/mistral-vibe) (beta), [Grok Build](https://docs.x.ai/build/overview) (beta), [Cursor CLI](https://cursor.com/docs/cli/overview) (beta), [Qwen Code](https://qwenlm.github.io/qwen-code-docs/en/) (beta) or [OpenCode](https://opencode.ai/docs/cli/) (beta) on your `PATH`, logged in | `claude --version`, `codex --version`, `agy --version`, `vibe --version`, `grok --version`, `cursor-agent --version`, `qwen --version`, `opencode --version` |
Two things worth knowing before you start:
@@ -36,7 +36,13 @@ On macOS there is an [app](mac-app.md) that does all of this from a window, Node
curl -fsSL https://browsentic.com/install.sh | sh
```
-Everywhere else, and on a Mac if you would rather not have the app:
+On Windows there is [one too](windows-app.md). In PowerShell:
+
+```powershell
+irm https://browsentic.com/install.ps1 | iex
+```
+
+Everywhere else, and on either if you would rather not have the app:
```sh
npx browsentic setup
diff --git a/docs/guide/limits.md b/docs/guide/limits.md
index 4029660..2ebc52b 100644
--- a/docs/guide/limits.md
+++ b/docs/guide/limits.md
@@ -97,9 +97,9 @@ yet, so the popup, the docs and the release notes say *beta*. What that means in
## Windows is experimental
-The daemon runs on Windows and its tests run there on every change, but nobody has yet taken the
-whole of it — setup, pairing, a side-panel run, a cancelled one — through a Windows desktop. Until
-someone has:
+The daemon runs on Windows and its tests run there on every change. On a Windows 11 desktop it has
+been set up, paired and driven from the side panel by Claude Code; a cancelled run, the other agents
+and the [Windows app](windows-app.md) have not been taken through one yet. Until they have:
- **An agent installed with npm is started through the program its `.cmd` names**, never through
`cmd.exe`, which can pass neither a prompt's many lines nor page text intact. A batch file that is
diff --git a/docs/guide/mac-app.md b/docs/guide/mac-app.md
index 4ebfa68..4b6151e 100644
--- a/docs/guide/mac-app.md
+++ b/docs/guide/mac-app.md
@@ -4,7 +4,7 @@ A native app that installs Browsentic and runs it from a window. It is the same
same daemon as [`npx browsentic setup`](install.md) — the app carries them inside itself, lays them
down in `~/.browsentic`, and then drives them, so nothing here needs a terminal.
-Requires macOS 14 or newer, on Apple silicon or Intel.
+Requires macOS 14 or newer, on Apple silicon or Intel. On Windows, the [Windows app](windows-app.md) is the same thing.
---
diff --git a/docs/guide/troubleshooting.md b/docs/guide/troubleshooting.md
index 6770ac2..3ca33b9 100644
--- a/docs/guide/troubleshooting.md
+++ b/docs/guide/troubleshooting.md
@@ -80,6 +80,9 @@ Those three answer most questions. The daemon log also lives at `~/.browsentic/d
| Cursor CLI is less fenced off on Windows | Cursor's kernel sandbox has no Windows backend | Nothing to do — the deny rules still apply; treat a Windows run as `host`-class |
| Windows: `AGENT_UNUSABLE`, *a batch file Browsentic cannot see through* | The agent's command is a batch file that is not an npm or pnpm shim, and Browsentic never runs one through `cmd.exe` | Set `agents.<name>.bin` to the `.exe` it runs |
| Windows: *This turn is too long for Windows to start* | Codex's `exec` fallback, Qwen Code and Grok Build pass the prompt as an argument, and Windows caps a command line at 32,767 characters | Start a new conversation, or leave out long site notes, attached files or fetched data. Claude Code is not affected |
+| Windows: *Windows protected your PC* when opening the installer | The installer is not code-signed yet, and SmartScreen checks every file a browser downloaded | Press **More info → Run anyway**, or install with `irm https://browsentic.com/install.ps1 \| iex`, which leaves no download mark |
+| Windows: `browsentic` is not recognized, though the app put it on the `PATH` | The terminal was open before; it keeps the `PATH` it started with | Open a new terminal |
+| Windows: the app says another `browsentic` is on your `PATH` | An `npm install --global browsentic` comes first, and would run an older copy than the app's | `npm rm -g browsentic` |
| `AGENT_UNSAFE`: *Grok Build offered this run …* | Grok offered tools Browsentic never asks for, so the run was stopped before the model saw them | Update Grok Build and Browsentic; report it if it persists |
| Qwen Code fails with *No auth type is selected* | Qwen has no provider configured, and its OAuth free tier ended on 2026-04-15 | Run `qwen` and use `/auth`, or export `OPENAI_API_KEY` with `OPENAI_BASE_URL` |
| Qwen Code cannot see an API key you exported | Only `QWEN_*`, `DASHSCOPE_*`, `BAILIAN_*` and `OPENAI_*` reach a run; the rest are sealed away | Point Qwen at one of those four providers |
diff --git a/docs/guide/windows-app.md b/docs/guide/windows-app.md
new file mode 100644
index 0000000..61f6e22
--- /dev/null
+++ b/docs/guide/windows-app.md
@@ -0,0 +1,135 @@
+# Browsentic for Windows
+
+An app that installs Browsentic and runs it from a window, the Windows counterpart of the
+[macOS app](mac-app.md). It is the same command and the same daemon as
+[`npx browsentic setup`](install.md): the app carries them inside itself, lays them down in
+`%USERPROFILE%\.browsentic`, and then drives them, so nothing here needs a terminal.
+
+Requires Windows 10 or 11, on x64 or ARM64. Windows is still [experimental](limits.md#windows-is-experimental).
+
+---
+
+## Install
+
+In PowerShell:
+
+```powershell
+irm https://browsentic.com/install.ps1 | iex
+```
+
+That downloads the latest release's installer for your computer's architecture, installs it for
+you alone, and opens the app. It asks for no administrator. `$env:BROWSENTIC_VERSION = '0.8.0'` pins a
+release, and `$env:BROWSENTIC_NO_OPEN = '1'` installs without opening.
+[Read the script](https://browsentic.com/install.ps1) first if you like; it is eighty lines.
+
+### From the installer instead
+
+Download `Browsentic-<version>-x64-setup.exe`, or `-arm64-setup.exe` on an ARM computer, from the
+[latest release](https://github.com/imshaikot/browsentic/releases/latest) and run it. The installer
+is not code-signed yet, so SmartScreen stops a downloaded copy with “Windows protected your PC”:
+press **More info**, then **Run anyway**. The one-line install avoids that, because a file PowerShell
+downloads carries no mark for SmartScreen to check.
+
+The app installs to `%LOCALAPPDATA%\Browsentic`, adds itself to the Start menu, and uses the
+WebView2 runtime that Windows 11 ships with (Windows 10 downloads it during the install if it is
+missing).
+
+## The first screen: what your computer already has
+
+The app opens on six checks and runs them on its own:
+
+| Check | Passes when | If it does not |
+| --- | --- | --- |
+| **This computer** | always | — |
+| **Node.js runtime** | `node` 20 or newer is on your `PATH` | **Install** downloads the current LTS from nodejs.org into `%USERPROFILE%\.browsentic\runtime\node`, verified against its published SHA-256. No administrator |
+| **Browsentic command** | `%USERPROFILE%\.browsentic\cli` holds the version this app carries | **Install** copies it there and writes the `browsentic.exe` launcher to `%USERPROFILE%\.browsentic\bin` |
+| **Browser extension** | the same version is unpacked at `%USERPROFILE%\browsentic\extension\chrome-mv3` | **Install** unpacks it |
+| **A Chromium browser** | Chrome, Edge, Brave, Vivaldi, Opera or Chromium is installed | **Get Chrome** opens the download page. Advisory: it does not block you |
+| **An AI agent** | One of `claude`, `codex`, `agy`, `vibe`, `grok`, `cursor-agent`, `qwen` or `opencode` is on your `PATH` | **Install Claude Code** runs `npm install --global @anthropic-ai/claude-code`. Advisory |
+
+**Set up everything** installs the first three in one click. A browser and an agent are yours to
+choose, so each has a button of its own. When everything required is in place the app moves on by
+itself.
+
+Claude Code on Windows also needs [Git for Windows](https://git-scm.com/downloads/win), which it
+runs its shell commands through.
+
+## The window
+
+The tabs float at the top; Ctrl+1 to Ctrl+7 switch between them. Ctrl+Shift+D turns the daemon
+on or off, Ctrl+Shift+R restarts it, and Ctrl+Shift+P gets a new pairing code.
+
+| Tab | What you do there |
+| --- | --- |
+| **Overview** | Turn the daemon on and off with the power button, restart it, see its address, version and whether the extension is connected and in sync. Copy the extension's folder, or open `chrome://extensions` in your browser with the folder already on the clipboard |
+| **Browsers** | Get a [pairing code](pair.md) with a live countdown, see every paired browser, unpair one or all |
+| **Agents** | See which agent CLIs are ready, [switch](agents.md) between them, pick a model, install a missing one, or let Browsentic fix what one still needs |
+| **Skills** | Every [skill](features/skills.md) the router can see and which folder it came from |
+| **Activity** | Your standing [approvals](approvals.md), forgettable per site, and the downloads agents captured |
+| **Logs** | `%USERPROFILE%\.browsentic\daemon.log`, followed live |
+| **Settings** | Light, dark or system appearance for this window; whether the daemon starts with the app; the **Browser theme** and **Guardrails** every paired browser uses, the same rows as the extension's settings page, kept in step both ways; `browsentic` in your terminal; the line that registers Browsentic with an [MCP client](mcp-clients.md); uninstall |
+
+The Browsentic icon in the notification area shows the daemon's state and has the same on, off and
+restart, and a left click opens the window.
+
+**Closing the window does not stop anything.** The app stays in the notification area, and the
+daemon is a background process of its own, so the side panel and any MCP client keep working with
+the app closed or quit.
+
+## Loading the extension
+
+Browsers load an unpacked extension only by hand. **Extensions in Google Chrome** (or Edge, or
+Brave) on the Overview tab opens `chrome://extensions` with the extension's folder on the
+clipboard. Turn on **Developer mode**, press **Load unpacked**, click the folder picker's address
+bar, paste, and press Enter. Then open the Browsentic popup and paste a pairing code.
+
+## `browsentic` in your terminal
+
+**Settings → “browsentic” in your terminal** adds `%USERPROFILE%\.browsentic\bin` to your user
+`PATH`. No administrator is asked for, and nothing else in the `PATH` changes. Terminals that were
+already open keep the `PATH` they started with, so open a new one. After that every command in the
+[CLI reference](../reference/cli.md) works, against the same install the app manages.
+
+`browsentic.exe` is a small program, not a `.cmd` script, so MCP clients start it directly:
+
+```powershell
+claude mcp add browsentic -- browsentic mcp
+```
+
+If you also have `npm install --global browsentic`, remove it (`npm rm -g browsentic`) so there is
+one command, not two that can drift apart. The Settings tab says so when it finds one.
+
+## Updating
+
+The app asks GitHub for a newer release when it opens and every few hours after. When one is out,
+a card appears at the top of **Overview** (and in Settings) with **Update now**: it downloads the new
+installer, checks it carries a signature from Browsentic's release key, runs it, and reopens the app,
+which replaces the command and the extension and restarts the daemon. Then press ↻ on the Browsentic
+card at `chrome://extensions`, which is the one step no installer can do for you. **Check for
+updates** on the same card asks again on the spot.
+
+If an update fails nothing is changed, and the card hands you the PowerShell line, which installs
+the same release.
+
+`browsentic update` does not replace an install the app made; it says so and points back here.
+
+## Uninstall
+
+**Settings → Uninstall…** runs [`browsentic uninstall`](../reference/cli.md#uninstall): it unpairs
+every browser, stops the daemon and removes `%USERPROFILE%\.browsentic` and `%USERPROFILE%\browsentic`,
+optionally keeping your skills. Remove the Browsentic card at `chrome://extensions` first. Then
+uninstall the app itself in **Settings › Apps › Installed apps**.
+
+Uninstalling only the app, from Installed apps, stops the daemon and takes `browsentic` off your
+`PATH`, and leaves your pairing, settings and skills where they are, as dragging the macOS app to
+the Trash does.
+
+## Building it yourself
+
+```powershell
+yarn win:app # → src\windows\target\release\bundle\nsis\Browsentic_<version>_<arch>-setup.exe
+```
+
+That needs Node.js, Yarn and the Rust toolchain. `yarn win:preview` opens the window in your
+browser against a stand-in daemon, on any computer. The source is a Tauri app in
+[`src/windows/`](../../src/windows); see [internals/windows-app.md](../internals/windows-app.md).
diff --git a/docs/internals/README.md b/docs/internals/README.md
index 96b98f7..951a655 100644
--- a/docs/internals/README.md
+++ b/docs/internals/README.md
@@ -23,6 +23,7 @@ Read in order, these pages follow a request through all of them:
| **9.** [State on disk](state.md) | Every file Browsentic writes, and why it is where it is |
| **10.** [Contributing](contributing.md) | Build topology, the checks, and adding a capability |
| **11.** [The macOS app](mac-app.md) | What is native, what stays in the daemon, and how the payload is laid down |
+| **12.** [The Windows app](windows-app.md) | The same app in Tauri and React, the launcher, the PATH, and how it updates |
Looking for an error code? [reference/errors.md](../reference/errors.md).
diff --git a/docs/internals/state.md b/docs/internals/state.md
index 5b35236..dcef3dc 100644
--- a/docs/internals/state.md
+++ b/docs/internals/state.md
@@ -16,9 +16,9 @@ Nothing lives in the repository.
├── stopped only after `browsentic stop`: the helper leaves the daemon down
├── daemon.log run starts, routed skills, every tool call and its outcome
├── skills/ hand-written skill overrides
-├── cli/ macOS app only: the command, the daemon, bundled skills, the extension payload
-├── bin/ macOS app only: the `browsentic` and `browsentic-mcp` launchers
-└── runtime/node/ macOS app only, and only when the Mac had no Node 20+: a private copy from nodejs.org
+├── cli/ desktop apps only: the command, the daemon, bundled skills, the extension payload
+├── bin/ desktop apps only: the `browsentic` and `browsentic-mcp` launchers (.exe on Windows)
+└── runtime/node/ desktop apps only, and only when the computer had no Node 20+: a private copy from nodejs.org
~/browsentic/ (paths configurable)
├── extension/chrome-mv3/ the unpacked extension `browsentic setup` installs
@@ -32,13 +32,13 @@ Nothing lives in the repository.
| --- | --- | --- |
| `daemon.json` | Each daemon at startup | The control token dies with the daemon that minted it. Read it with `browsentic token` |
| `auth.json` | Pairing | Session keys are per browser profile, keyed by its install id, and survive restarts. Cleared by `browsentic revoke` |
-| `config.json` | You, the agent picker, and the settings page and Mac app for `theme` and `guardrails` | Re-read before every run — no restart needed — and watched, so a hand edit reaches every open settings screen. [Reference](../guide/configuration.md) |
+| `config.json` | You, the agent picker, and the settings page and desktop app for `theme` and `guardrails` | Re-read before every run — no restart needed — and watched, so a hand edit reaches every open settings screen. [Reference](../guide/configuration.md) |
| `approvals.json` | **Always on ‹host›** | One action + host per entry. Only short-circuits a `confirm` |
| `models.json` | The daemon, reading each agent CLI's model list | A cache: deleting it only means the lists are read again. A failed read keeps the last list that read cleanly |
| `schedules.json` | The Schedules tab, `browsentic tasks` | At most 25 tasks. The daemon re-reads it every minute, so an edit from the CLI lands without a restart. Transcripts stay in the extension: the last three runs of each task |
| `native-host/` | `browsentic setup` | A launcher that runs this CLI with the `PATH` setup saw. Each browser gets a manifest in its own `NativeMessagingHosts` folder (a registry key on Windows) naming the extension origins allowed to use it; pairing adds the new one. `browsentic uninstall` removes both |
| `stopped` | `browsentic stop` and `restart` | While it exists the helper starts no daemon, so a paired browser cannot undo a stop. The next daemon to start removes it |
-| `cli/`, `bin/`, `runtime/` | [Browsentic.app](../guide/mac-app.md) | Replaced whole on every app update. `cli/.browsentic-app.json` is what makes `installKind()` answer `app`, which turns the npm self-update off |
+| `cli/`, `bin/`, `runtime/` | The [macOS](../guide/mac-app.md) or [Windows](../guide/windows-app.md) app | Replaced whole on every app update. `cli/.browsentic-app.json` is what makes `installKind()` answer `app`, which turns the npm self-update off |
| `daemon.log` | The daemon | `browsentic logs`. Local [instant commands](../guide/features/instant-commands.md) never appear here, by design |
## The one that is not yours
diff --git a/docs/internals/windows-app.md b/docs/internals/windows-app.md
new file mode 100644
index 0000000..edc7eb5
--- /dev/null
+++ b/docs/internals/windows-app.md
@@ -0,0 +1,125 @@
+# The Windows app
+
+`src/windows/` is a [Tauri 2](https://tauri.app) app: a Rust shell in `src-tauri/`, a React window
+in `ui/`, and the `browsentic.exe` launcher in `launcher/`. Like the [macOS app](mac-app.md) it
+**installs** the Node half of Browsentic and then **drives** it, screen for screen the same, and it
+holds no intelligence of its own: the daemon stays the daemon, for the reasons given there.
+
+## Why Tauri and React
+
+The macOS app is SwiftUI, with the extension's palette converted into Swift by hand. On Windows
+the window is the extension's own stack: `ui/app.css` imports
+[globals.css](../../src/extension/assets/globals.css), so Ember and Daylight are the same tokens,
+not a copy of them, and the guardrail rows and the theme picker are the extension's components
+([guardrail-policy.tsx](../../src/extension/components/guardrail-policy.tsx),
+[theme-picker.tsx](../../src/extension/components/theme-picker.tsx)), so a rule added to the
+daemon shows up here the moment it shows up in the settings page. The frames it speaks are typed by
+[control.ts](../../src/daemon/control.ts) itself, where the Swift app declares its own.
+
+Tauri renders with WebView2, which Windows 11 ships, so the installer is about 2 MB and carries
+no browser engine. The Rust half is only what a webview cannot do.
+
+## Two ways in, by cost
+
+The same split as the macOS app:
+
+| Path | Used for | Where |
+| --- | --- | --- |
+| **The control socket**: `ws://127.0.0.1:<port>/control`, bearer token from `daemon.json` | `status`, `sessions`, `pair`, `revoke`, `agent` set and grant, `preferences` and `setPreference` | [control.rs](../../src/windows/src-tauri/src/control.rs) |
+| **The installed command**: `node %USERPROFILE%\.browsentic\cli\dist\cli.js …` | `start`, `stop`, `restart`, `setup`, `uninstall`, and the `--json` listings | [main.rs](../../src/windows/src-tauri/src/main.rs) `cli` |
+
+The socket is held in Rust because the daemon authenticates `/control` with an `Authorization`
+header, and a webview's WebSocket cannot send one. Replies are matched to requests by id, and the
+daemon's unprompted `settings-changed` reaches the window as a Tauri event.
+
+The command starts from the home folder, with no console window (`CREATE_NO_WINDOW`), and a
+daemon it starts inherits that folder, so no install folder is ever held open, which is what lets
+the updater replace the app and the payload swap rename `cli`.
+
+[model.ts](../../src/windows/ui/model.ts) is `AppModel.swift` ported: the same phases, the
+same six checks and their messages, the same two-second poll.
+[backend.ts](../../src/windows/ui/backend.ts) is everything it asks of the machine, so
+[mock-backend.ts](../../src/windows/ui/mock-backend.ts) can stand in for it: `yarn win:preview`
+runs the window in any browser, and `model.test.ts` drives the real model through it.
+
+## The payload
+
+[scripts/windows-payload.ts](../../scripts/windows-payload.ts) runs before every Tauri build and
+stages what the macOS app's `build-app.sh` stages: the npm package's layout (`dist/cli.js`,
+`dist/daemon-main.js`, `skills/`, `extension/chrome-mv3/`, `package.json`) under
+`src-tauri/resources/payload`, refusing a build whose extension, daemon and package versions
+disagree. It also builds the launcher for the target Tauri names, through `cargo-xwin` when the
+build is not on Windows.
+
+**Set up everything** then does what the macOS app does, in
+[payload.rs](../../src/windows/src-tauri/src/payload.rs):
+
+- the payload is copied into a staging folder and swapped into `%USERPROFILE%\.browsentic\cli`
+ whole, with the `.browsentic-app.json` marker that makes `installKind()` answer `app`, so
+ `browsentic update` leaves it to the app;
+- a running daemon is stopped first, because Windows will not rename a folder a process has open,
+ and started again after;
+- `browsentic.exe` and `browsentic-mcp.exe` go to `%USERPROFILE%\.browsentic\bin`. Windows will not
+ overwrite a running program but will rename one, so a launcher an MCP client still holds is
+ renamed aside and swept later.
+
+The payload is "current" only when the version matches **and** the marker is there, the lesson the
+macOS app learned from a same-version build installed over a release.
+
+## The launcher
+
+[launcher/src/main.rs](../../src/windows/launcher/src/main.rs) is the `browsentic` command on
+Windows. It finds Node (the one the marker records, then the private copy, then `PATH`), runs
+`cli.js` with the terminal's input and output, and exits with Node's code. Invoked as
+`browsentic-mcp`, with no arguments, it runs `mcp`.
+
+It is a real program rather than a `.cmd` because MCP clients start their server without a shell,
+and Node refuses to start a `.cmd` without one. Windows has no `exec`, so Node stays its child: a
+job object with `KILL_ON_JOB_CLOSE` ends Node when the launcher is ended, and
+`SILENT_BREAKAWAY_OK` lets everything Node starts, the daemon above all, leave the job and outlive
+it.
+
+## PATH
+
+**“browsentic” in your terminal** writes `%USERPROFILE%\.browsentic\bin` into the user `PATH` in the
+registry (`HKCU\Environment`), as `REG_EXPAND_SZ` so entries like `%USERPROFILE%` keep expanding,
+and broadcasts `WM_SETTINGCHANGE` so terminals opened afterwards see it
+([path_env.rs](../../src/windows/src-tauri/src/path_env.rs)). Every program the app starts gets the
+`PATH` a new terminal would, read from the registry, so an agent installed while the app is open is
+found without restarting it.
+
+## Updating and uninstalling
+
+The updater is Tauri's, driven from [update.rs](../../src/windows/src-tauri/src/update.rs). It reads
+`latest.json` from the latest GitHub release, which the release workflow writes once both installers
+are attached, and installs only a download signed by the key whose public half is in
+`tauri.conf.json`; the private half is the `TAURI_SIGNING_PRIVATE_KEY` repository secret.
+`BROWSENTIC_UPDATE_URL` points a test build at another feed; the signature check still applies. The
+new installer runs in passive mode, and the next launch finds a newer payload than the one installed
+and sets it up without a press, as `finishUpdateOnLaunch` does on macOS.
+
+The installer is NSIS, per user, into `%LOCALAPPDATA%\Browsentic`.
+[installer-hooks.nsh](../../src/windows/src-tauri/installer-hooks.nsh) runs `Browsentic.exe
+--uninstall` before a real uninstall, which stops the daemon and takes `bin` off the `PATH`; an update
+also runs the old uninstaller, with `/UPDATE`, and the hook skips it then.
+
+## Build and test
+
+```powershell
+yarn win:app # the extension, the daemon, the payload, then the NSIS installer
+yarn win:preview # the window in a browser, against mock-backend.ts
+yarn vitest run --project windows
+cd src\windows; cargo test --workspace
+```
+
+From macOS, the same installer cross-builds with `cargo-xwin`, LLVM and NSIS (`brew install
+rustup llvm makensis`, `cargo install cargo-xwin`, and the `aarch64-pc-windows-msvc` or
+`x86_64-pc-windows-msvc` target):
+
+```sh
+yarn build && yarn daemon:build
+yarn tauri build --runner cargo-xwin --target aarch64-pc-windows-msvc
+```
+
+CI's `windows-app` job builds and tests the Rust half on `windows-latest`; the release workflow's
+`windows-app` job builds an installer per architecture and `windows-feed` writes `latest.json`.
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index d4eb4c2..00b96cd 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -108,8 +108,8 @@ configurations written against the older name keep working.
| `browsentic downloads clear` | Delete all of them |
| `browsentic token` | The control token, for MCP clients. Not for the browser |
-`agent`, `skills`, `approvals`, `tasks` and `downloads` take `--json`. It is what the [macOS app](../guide/mac-app.md)
-reads, so the app and a terminal can never disagree about what is on disk.
+`agent`, `skills`, `approvals`, `tasks` and `downloads` take `--json`. It is what the [macOS](../guide/mac-app.md) and
+[Windows](../guide/windows-app.md) apps read, so an app and a terminal can never disagree about what is on disk.
## Lifecycle
@@ -140,6 +140,8 @@ Not the CLI, but frequently wanted alongside it:
| `yarn check` | Both type checks plus both fixture suites |
| `yarn mac:app` | Build both halves, then `dist/mac/Browsentic.app` around them (macOS only) |
| `yarn mac:dmg` | The same, wrapped in `dist/mac/Browsentic-<version>.dmg` |
+| `yarn win:app` | Build both halves, then the Windows app's installer around them (Windows, or macOS with `cargo-xwin`) |
+| `yarn win:preview` | The Windows app's window in a browser, against a stand-in daemon |
| `yarn check:intent "<utterance>"` | Explain how one instruction would be routed |
Full list: [internals/contributing.md](../internals/contributing.md).