@materialwebunofficial/antigravity-themes 1.0.4 → 1.0.13

package/README.md

@@ -1,7 +1,9 @@
 # antigravity-themes
 
-Two themes for Antigravity Desktop: **Matte** and **Material 3 Expressive**
-(in five colors). They are applied to the running app; no app file is changed.
+Four themes for Antigravity Desktop: **Matte**, **Nordic Frost**, **E-Ink /
+Paper** and **Material 3 Expressive** (in five colors). Each one restyles the
+whole app in its own structure, Settings, menus, dialogs and sidecar panes
+such as Swarm included, rather than recoloring Antigravity's default look.
 
 This is an unofficial project. It is not affiliated with, endorsed by or
 sponsored by Google.
@@ -9,12 +11,18 @@ sponsored by Google.
 ## Install
 
 ```sh
-npx -y @materialwebunofficial/antigravity-themes install
+npx -y @materialwebunofficial/antigravity-themes install --native
 ```
 
 That is all. It takes a few seconds, needs no administrator rights, and it is
-permanent: the themes return at every logon and every Antigravity start, until
-you uninstall them. It needs [Node.js](https://nodejs.org) 22 or newer.
+permanent: the themes stay after closing Antigravity, after restarting the
+computer and after Antigravity updates itself, with nothing running in the
+background and nothing to reinstall. It needs [Node.js](https://nodejs.org) 22
+or newer (only to run the command; the themes do not need it afterwards).
+
+Without `--native`, `install` leaves Antigravity's files untouched and applies
+the themes from a small background process instead (see
+[What install does](#what-install-does)).
 
 On Windows, if PowerShell says running scripts is disabled, use `npx.cmd` in
 place of `npx`.
@@ -50,12 +58,44 @@ code 0 means installed and permanent.
 
 ## Requirements
 
-- Antigravity Desktop. Tested with version 2.28 on Windows 11.
+- Antigravity Desktop. Tested with versions 2.31.0 and 2.31.2 on Windows 11
+  (the keeper carried the themes across that update on its own).
   macOS and Linux are supported in the code but untested.
 - [Node.js](https://nodejs.org) 22 or newer. Check with `node --version`.
 
 ## What install does
 
+### `install --native` (recommended)
+
+1. Stops a background process from an earlier `install`, if any, and removes
+   its logon entry and its folder, so an older version cannot replace the
+   themes.
+2. Writes the themes into Antigravity's own files. Antigravity loads
+   `resources/app` before its `app.asar` archive, so the app is extracted
+   there once and two of its files are patched: the window's preload
+   (`dist/preload.js`) runs the theme script, and the main process
+   (`dist/main.js`) runs the frame script in each sidecar pane (Swarm), which
+   a preload cannot reach. A stamp, `resources/app/agy-themes.json`, records
+   which build of the themes is in place.
+3. Adds a small Antigravity plugin, `~/.gemini/config/plugins/antigravity-themes`,
+   holding the **keeper**. Antigravity itself starts the keeper (as a plugin
+   sidecar, with its own built-in Node) every time it launches:
+   - when the themes are in place, the keeper exits at once;
+   - after an Antigravity update, which replaces `resources`, it extracts and
+     patches the app again (about a second) and themes the open windows right
+     away, so the update shows the themes on its first start.
+4. Applies the themes to the open windows and panes now.
+
+While Antigravity runs, Windows keeps its `app.asar` locked; if an earlier
+version of this tool had patched that archive, `install --native` says so.
+It is harmless (Antigravity loads `resources/app`); run the command again with
+Antigravity closed to restore the original archive.
+
+Turning the plugin off in Antigravity stops the keeper: the themes then last
+until the next Antigravity update.
+
+### `install` (background process)
+
 1. Copies this package to a folder in your user profile:
 
    | System  | Folder |
@@ -79,9 +119,6 @@ code 0 means installed and permanent.
    To skip this, use `npx -y @materialwebunofficial/antigravity-themes install --no-autostart` and
    run `npx -y @materialwebunofficial/antigravity-themes start` when you want the themes.
 
-   **Direct / Native Install (Zero background processes):**
-   Use `npx -y @materialwebunofficial/antigravity-themes install --native` to inject the themes directly into Antigravity's Electron resources. This runs with ZERO background processes, no listening ports, and no startup entries.
-
 3. Starts a small background Node.js process. It applies the theme to every
    Antigravity window, keeps it applied when a window reloads, and waits
    quietly while Antigravity is closed.
@@ -91,7 +128,8 @@ code 0 means installed and permanent.
 
 ## Choosing a theme
 
-- **Matte**: open the **Theme** menu in the title bar.
+- **Matte**, **Nordic Frost**, **E-Ink / Paper**: open the **Theme** menu in
+  the title bar.
 - **Material 3 Expressive**: the title bar menus (Antigravity, Workspace,
   View, Window, Theme) are gathered into one menu button at the top left.
   Open it, then **Theme**.
@@ -102,7 +140,10 @@ code 0 means installed and permanent.
 
 | Key           | Theme |
 | ------------- | ----- |
+| `antigravity` | Antigravity's own look (the themes off) |
 | `matte`       | Matte (the default) |
+| `nordic`      | Nordic Frost |
+| `paper`       | E-Ink / Paper |
 | `md3e-teal`   | Material 3 Expressive, Teal |
 | `md3e-ocean`  | Material 3 Expressive, Ocean |
 | `md3e-forest` | Material 3 Expressive, Forest |
@@ -110,42 +151,102 @@ code 0 means installed and permanent.
 | `md3e-coral`  | Material 3 Expressive, Coral |
 
 Your choice is remembered. Light and dark follow Antigravity's own
-appearance setting; both themes have a light and a dark version.
+appearance setting; every theme has a light and a dark version.
 
 ## What the themes change
 
+Each theme has its own layout language, carried through the Settings dialog
+(navigation, page titles, groups, rows, switches, selects, buttons, segmented
+controls, sliders, fields, option cards, key caps, usage rings and token
+bars), dialogs, menus, the "Restart to Update" button and the Swarm pane.
+None of them loops an animation (the app's own pulsing update button is
+stilled), and hovers keep text at WCAG AA contrast or better.
+
 **Matte** is quiet and fast: a near-black window holding one rounded panel,
 small neutral steps between surfaces, 1px lines for structure, and no
-gradients, blur, glow or looping animation.
+gradients, blur or glow. Settings reads like an inspector: a darker index
+column with a bright bar on the current page, plain rows ruled by hairlines
+under small uppercase labels, compact 28px controls in raised gray, mono key
+caps, and a switch that is the one bright thing when on.
+
+**Nordic Frost** uses the [Nord](https://www.nordtheme.com) palette: Polar
+Night surfaces, Snow Storm text, Frost accents, Aurora for status. Settings
+is a preferences window: a raised index column with Frost group headings,
+every group a solid tile with grooves of the base color between its rows,
+flat filled controls with no strokes, and Frost marking what is on or chosen.
+
+**E-Ink / Paper** is strict monochrome for reading: ink on paper (or paper
+on ink), a serif for headings and prose, square corners, rules instead of
+shadows, and no in-between animation frames. Settings is a printed form: a
+serif index with the current page printed in reverse, small-capital group
+titles under a heavy rule, ruled boxes with dashed lines between entries,
+square ink controls that print in reverse when chosen, and fields drawn as
+lines to write on.
 
 **Material 3 Expressive** maps the Material 3 Expressive design system onto
 the app: its color schemes, the Roboto type scale, shapes, state layers,
 ripples and spring motion; Material Symbols Rounded icons; a navigation
-drawer style sidebar; the app menu button; a shape-morphing loading
+drawer style sidebar (title-small group headlines, dividers between the
+destinations and every group); the app menu button; a shape-morphing loading
 indicator while the agent works; and wavy progress bars for running
 background commands and tasks. The menu and the indicators are the
-[md3e-web](https://materialwebunofficial.github.io) components.
-
-Both themes also add:
+[md3e-web](https://materialwebunofficial.github.io) components. In detail:
+
+- **Settings** follows M3's list-detail layout: a navigation drawer beside
+  the page, which is a pane with large corners; settings are M3 Expressive
+  segmented lists (items 2px apart, 4px corners inside a group, 20px
+  outside) under title-small primary category headers; M3 switches (the
+  handle springs on the compositor), sliders, connected button groups (the
+  selection fades and morphs, the pressed button widens), filled text
+  fields, outlined selects whose lists are M3 menus, and filled or tonal
+  buttons whose corners close when pressed. Shape morphs run between real
+  radii, never from the 9999px "full" token, so the spring's overshoot
+  cannot flash square corners, and a ripple follows its button's box and
+  corners while it plays.
+- **Usage** (the model menu's View Usage, and Settings > Models & Usage):
+  M3 circular progress indicators, with the gap between the arc and its
+  track; the menu's usage view is a list of two-line menu items.
+- **Dialogs** are M3 dialogs, **artifact cards** (plans, reports) are filled
+  cards with a filled Proceed and a tonal split Open button, and **Restart to
+  Update** is an extra-small filled button with a refresh icon.
+
+Every theme also adds:
 
 - **Context** at the top of the Overview panel: how full the conversation's
   context window is and what takes it up (system prompt, tools, rules, MCP
   tools, skills and so on), with a warning at 80% and at 95%. The app does
   not report context window sizes, so they are assumed by model family:
-  Gemini 1M tokens, Claude 200k, GPT-OSS 128k.
+  Gemini 256k tokens, Claude 200k, GPT-OSS 128k.
 - **Token counts** under each finished agent turn, for example
   `2.5k in · 358 out · 142k cache`.
 - **Wrap lines** and **Line numbers** buttons beside "Copy code" in chat
   code blocks. Line numbers are not copied.
 
+Sidecar panes such as **Swarm** follow the theme too. Each is a separate page
+(a `plugin://` frame) with its own styles, so every theme has a frame style
+sheet for it (`themes/frames/`), loaded inside the frame by a small frame
+script. In Material 3 Expressive the Swarm board is a list of tonal rows with
+primary tabs, a search bar, filter chips and an M3 switch and slider, and its
+Live status is the md3e-web loading indicator: still while the board is
+connected, morphing when new posts arrive, running while it reconnects.
+Swarm's dropdowns use Chromium's customizable select (`appearance:
+base-select`), so their lists are drawn in the page and follow each theme: an
+M3 menu in Material 3 Expressive, a hairline panel in Matte, a Polar Night
+tile in Nordic Frost, a ruled box in E-Ink / Paper.
+
+Chips inside a sent message (quotes, files, terminal output) take the
+message bubble's own ink in every theme, so a quote stays readable on any
+bubble color.
+
 ## Commands
 
 Run each as `npx -y @materialwebunofficial/antigravity-themes <command>`.
 
 | Command | What it does |
 | ------- | ------------ |
+| `install --native` | Write the themes into Antigravity and add the keeper plugin: no background process, kept across restarts and updates (see above) |
 | `install [--no-autostart]` | Install, add the logon entry, and start the background process (see above) |
-| `uninstall` | Remove everything `install` added (see below) |
+| `uninstall` | Remove everything either install added (see below) |
 | `start` | Start the background process |
 | `stop` | Stop it. Open windows keep the theme until they reload |
 | `on` | Apply the themes to the open windows once, without the background process |
@@ -157,11 +258,18 @@ Run each as `npx -y @materialwebunofficial/antigravity-themes <command>`.
 
 ## Update
 
+Antigravity updates need nothing: with the native install, the keeper puts
+the themes back at the first start after the update.
+
+To get a newer version of the themes:
+
 ```sh
-npx -y @materialwebunofficial/antigravity-themes@latest install
+npx -y @materialwebunofficial/antigravity-themes@latest install --native
 ```
 
-This replaces the installed copy and restarts the background process.
+This patches the app with the new build, replaces the keeper's copy and
+applies the new themes to the open windows. (With the background install,
+`install` without `--native` replaces its copy and restarts the process.)
 
 ## Uninstall
 
@@ -169,15 +277,34 @@ This replaces the installed copy and restarts the background process.
 npx -y @materialwebunofficial/antigravity-themes uninstall
 ```
 
-This stops the background process, restores the app's own look in the open
-windows, and deletes the logon entry and the install folder.
+This removes the keeper plugin, takes the themes out of Antigravity's files
+(and, with Antigravity closed, deletes the extracted `resources/app` so the
+app runs from its own `app.asar` again), restores the app's own look in the
+open windows, and stops a background process and deletes its logon entry and
+install folder if there are any.
 
 Three small cookies stay in Antigravity's own storage (see Privacy). They
 have no effect without this tool.
 
 ## How it works
 
-Antigravity starts with the Chrome DevTools Protocol enabled on a local
+**Native install.** Electron loads an app folder, `resources/app`, before the
+`app.asar` archive. The installer extracts the archive there and adds the
+scripts to two of its files: the window's preload runs the theme script in
+every window as it loads, and the main process runs the frame script in each
+sidecar frame (`plugin://`, such as Swarm) as it navigates. Nothing listens
+on a port and nothing stays running.
+
+An update replaces `resources`, so the themes would be gone after it. The
+keeper plugin covers that: Antigravity discovers plugins in
+`~/.gemini/config/plugins/`, outside its install folder, and starts their
+sidecars itself at every launch. The keeper compares the stamp in
+`resources/app` with its own build; when they differ (or the folder is gone)
+it extracts and patches the app from its own copy of this package, then
+applies the themes to the windows that are already open over the app's local
+debugging port, and exits.
+
+**Background install.** Antigravity starts with the Chrome DevTools Protocol enabled on a local
 port, on every launch, and writes that port number to a file named
 `DevToolsActivePort` in its user data folder (`%APPDATA%\Antigravity` on
 Windows, `~/Library/Application Support/Antigravity` on macOS,
@@ -191,6 +318,11 @@ each window:
   (the menu, the code block buttons, the indicators), and
 - registers the same script to run again whenever the window reloads.
 
+In each sidecar frame (`plugin://`, such as Swarm) it runs the frame script
+instead: only the frame host and the themes' frame style sheets. The frame
+asks the window which theme, seed and light or dark mode is on, and the window
+tells every frame when that changes. No other frame is touched.
+
 To find and stop the background process, the other commands talk to it on
 `127.0.0.1` through a random port and a random token that it writes to
 `run.json` in the install folder while it runs.
@@ -219,17 +351,23 @@ Things to know:
   | `agy-code` | The Wrap lines and Line numbers settings |
   | `agy-usage` | Running token totals for your last 20 conversations, by conversation id |
 
-- Stored in the install folder: `run.json` (process id, control port, token
-  and version, while running), `run.log` (when windows were found and themed,
-  with their internal addresses; started anew when it reaches 512 KB) and, on
-  Windows, `start.vbs` (starts the background process with no window).
+- Native install: `resources/app/agy-themes.json` (the build in place and
+  the Antigravity version), and `keeper.log` in the data folder Antigravity
+  gives the keeper (what the keeper did at each start; started anew at
+  256 KB).
+- Background install, in the install folder: `run.json` (process id, control
+  port, token and version, while running), `run.log` (when windows were found
+  and themed, with their internal addresses; started anew when it reaches
+  512 KB) and, on Windows, `start.vbs` (starts the background process with no
+  window).
 
 ## Compatibility and known limits
 
-- The themes are written against Antigravity 2.28's interface (its class
+- The themes are written against Antigravity 2.31's interface (its class
   names, element ids and component data). An app update can break parts of
   them until this package is updated. If that happens,
-  `npx -y @materialwebunofficial/antigravity-themes off` restores the app's own look at once.
+  `npx -y @materialwebunofficial/antigravity-themes theme antigravity`
+  restores the app's own look at once, and `uninstall` removes everything.
 - Windows 11 is tested. macOS and Linux follow the platforms' usual folders
   and logon entries but have not been tested.
 - The context window sizes are assumptions (see above).
@@ -241,8 +379,9 @@ Things to know:
 - `npx -y @materialwebunofficial/antigravity-themes status` shows whether the themes are installed,
   whether the background process runs, and which Antigravity windows are
   themed.
-- The log is `run.log` in the install folder.
-- Antigravity looks wrong after an update: run `npx -y @materialwebunofficial/antigravity-themes off`
+- The logs are `keeper.log` (native install) and `run.log` in the install
+  folder (background install).
+- Antigravity looks wrong after an update: run `npx -y @materialwebunofficial/antigravity-themes theme antigravity`
   and [open an issue](https://github.com/materialwebunofficial/antigravity-themes/issues) with your Antigravity version.
 
 ## Development
@@ -262,9 +401,9 @@ at a time.
 | Path | Contents |
 | ---- | -------- |
 | `bin/cli.mjs` | The commands |
-| `lib/` | Finding Antigravity, the DevTools connection, logon entries |
-| `src/` | The scripts that run in the app: the theme host (menus, theme switching, ripples) and the context, token, code block and indicator features |
-| `themes/` | `index.json` (the theme list) and the CSS of each theme |
+| `lib/` | Finding Antigravity, the DevTools connection, logon entries, the native install (`native.mjs`, with `asar.mjs` for the archive), the keeper (`keeper.mjs`) and its plugin (`plugin.mjs`) |
+| `src/` | The scripts that run in the app: the theme host (menus, theme switching, ripples), the frame host for sidecar panes, and the context, token, code block and indicator features |
+| `themes/` | `index.json` (the theme list), each theme's tokens and CSS, and `frames/`: each theme's style sheet for sidecar panes |
 | `vendor/md3e/` | The md3e-web components, the Roboto font, and their licenses |
 | `tools/` | Generators for files in `themes/` and `vendor/` (below) |
 

package/bin/cli.mjs

@@ -4,10 +4,13 @@ import { randomUUID } from 'node:crypto';
 import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, watch as watchFiles, writeFileSync } from 'node:fs';
 import http from 'node:http';
 import path from 'node:path';
-import { ROOT, pageScript, REMOVE_SCRIPT, PROBE_SCRIPT, selectScript } from '../lib/bundle.mjs';
-import { readPort, evaluateEverywhere, watch } from '../lib/injector.mjs';
+import { ROOT, pageScript, frameScript, REMOVE_SCRIPT, PROBE_SCRIPT, selectScript } from '../lib/bundle.mjs';
+import { readPort, evaluateEverywhere, watch, scriptFor } from '../lib/injector.mjs';
 import { installDir, stateFile, logFile, portFile, appResourcesDir } from '../lib/paths.mjs';
 import { launch, writeAutostart, removeAutostart, hasAutostart, autostartFile } from '../lib/autostart.mjs';
+import { appState, buildId, ensureApp, patchApp, removeLegacyArchive, restoreArchive, unpatchApp } from '../lib/native.mjs';
+import { installPlugin, pluginDir, removePlugin } from '../lib/plugin.mjs';
+import { removeTree } from '../lib/asar.mjs';
 
 const NAME = 'antigravity-themes';
 const pkg = JSON.parse(readFileSync(path.join(ROOT, 'package.json'), 'utf8'));
@@ -101,7 +104,7 @@ async function run() {
     process.exit(1);
   });
   log(`${NAME} ${pkg.version} running from ${ROOT}`);
-  const watcher = watch({ getSource: () => pageScript(ROOT), log });
+  const watcher = watch({ getSource: () => scriptFor({ page: pageScript(ROOT), frame: frameScript(ROOT) }), log });
   if (has('--dev')) {
     let timer;
     for (const dir of ['src', 'themes', 'vendor']) {
@@ -118,50 +121,66 @@ async function run() {
 const RUNTIME = ['bin', 'lib', 'src', 'themes', 'vendor', 'package.json', 'README.md', 'LICENSE', 'NOTICE'];
 
 const isThemed = (result) => Boolean(result.value && JSON.parse(result.value));
+// Only the targets the themes go to: windows and sidecar frames
+const PROBE = scriptFor({ page: PROBE_SCRIPT, frame: PROBE_SCRIPT });
 
 // Waits for the background process to reach the open windows, so that install
 // can report the result itself. Throws when Antigravity is not open.
 async function themedWindows() {
   let results = [];
   for (let i = 0; i < 40; i++) {
-    results = await evaluateEverywhere(PROBE_SCRIPT);
+    results = await evaluateEverywhere(PROBE);
     if (results.length && results.every(isThemed)) break;
     await sleep(200);
   }
   return { themed: results.filter(isThemed).length, total: results.length };
 }
 
+// The permanent install: the scripts go into Antigravity's own files
+// (lib/native.mjs), and the keeper plugin (lib/plugin.mjs, lib/keeper.mjs)
+// puts them back after an Antigravity update. Nothing of ours keeps running.
 async function installNative() {
-  const { execSync } = await import('node:child_process');
-  const resDir = appResourcesDir();
-  const asarPath = path.join(resDir, 'app.asar');
-  const appDir = path.join(resDir, 'app');
-  if (!existsSync(asarPath) && !existsSync(appDir)) {
-    fail(`Could not find Antigravity resources at ${resDir}. Is Antigravity installed?`);
+  const resources = appResourcesDir();
+  if (!existsSync(path.join(resources, 'app.asar')) && !existsSync(path.join(resources, 'app'))) {
+    fail(`Could not find Antigravity resources at ${resources}. Is Antigravity installed?`);
   }
-  await stopBackground();
-  removeAutostart();
-
-  if (!existsSync(appDir)) {
-    say('Extracting Antigravity app.asar into resources/app...');
-    execSync(`npx -y @electron/asar extract "${asarPath}" "${appDir}"`, { stdio: 'inherit' });
+  if (await stopBackground()) say('Stopped the background process of an earlier install.');
+  const entry = removeAutostart();
+  if (entry) say(`Removed its logon entry: ${entry}`);
+  // the background install's own copy of the package is no longer used
+  const stale = installDir();
+  const background = ['bin', 'start.vbs', 'run.json'].some((f) => existsSync(path.join(stale, f)));
+  if (path.resolve(stale) !== path.resolve(ROOT) && background) {
+    try {
+      removeTree(stale);
+      say(`Removed the earlier background install: ${stale}`);
+    } catch (err) {
+      say(`Could not remove the earlier background install at ${stale} (${err.code || err.message}); it is unused.`);
+    }
   }
 
-  const bundleCode = pageScript(ROOT);
-  const bundleDest = path.join(appDir, 'dist', 'theme-bundle.js');
-  writeFileSync(bundleDest, bundleCode, 'utf8');
-
-  const preloadPath = path.join(appDir, 'dist', 'preload.js');
-  let preloadContent = readFileSync(preloadPath, 'utf8');
-  const marker = '// Antigravity Native Theme Injection (Zero background processes)';
-  if (!preloadContent.includes(marker)) {
-    const patch = `\n\n${marker}\n(function() {\n  try {\n    const electron = require('electron');\n    const path = require('path');\n    const fs = require('fs');\n    const b = path.join(__dirname, 'theme-bundle.js');\n    if (fs.existsSync(b)) {\n      const c = fs.readFileSync(b, 'utf8');\n      if (electron.webFrame) electron.webFrame.executeJavaScript(c);\n    }\n  } catch (e) {}\n})();\n`;
-    appendFileSync(preloadPath, patch, 'utf8');
+  const page = pageScript(ROOT), frame = frameScript(ROOT), build = buildId(page, frame);
+  try {
+    if (restoreArchive(resources)) say("Restored the app's own app.asar (an earlier version had patched it).");
+  } catch (err) {
+    say(`app.asar still holds an earlier patch: it is in use while Antigravity runs (${err.code || err.message}).`);
+    say('  Harmless, Antigravity loads resources/app; run install again with Antigravity closed to restore it.');
   }
+  if (removeLegacyArchive(resources)) say('Removed app.asar.patched, left by an earlier build.');
+  if (ensureApp(resources)) say(`Extracted the app to ${path.join(resources, 'app')}.`);
+  const { appVersion } = patchApp(path.join(resources, 'app'), { page, frame, build });
+  say(`Patched Antigravity ${appVersion}: the themes load with every start.`);
+  say(`Keeper plugin: ${installPlugin(ROOT, { build, version: pkg.version })}`);
+  say('  Antigravity runs it at each start; after an update it puts the themes back.');
 
-  say(`Installed natively into Antigravity (${resDir}).`);
-  say('No background process, no host server, and no startup entry.');
-  say('Done. The themes load permanently whenever Antigravity starts.');
+  try {
+    const results = await evaluateEverywhere(scriptFor({ page, frame }));
+    const applied = results.filter((r) => !r.error).length;
+    say(applied ? `Applied to ${applied} open window(s) and pane(s) now.` : 'Antigravity is open: the themes appear in new windows.');
+  } catch {
+    say('Antigravity is not open: the themes appear when it starts.');
+  }
+  say('Done. Permanent, across restarts and updates, with no background process and no logon entry.');
 }
 
 async function install() {
@@ -206,9 +225,13 @@ async function install() {
 }
 
 async function uninstall() {
+  const plugin = removePlugin();
+  if (plugin) say(`Removed the keeper plugin: ${plugin}`);
   if (await stopBackground()) say('Stopped the background process.');
+  let open = false;
   try {
     const results = await evaluateEverywhere(REMOVE_SCRIPT);
+    open = true;
     say(`Removed the theme from ${results.filter((r) => !r.error).length} open window(s).`);
   } catch {
     say('Antigravity is not running: nothing to remove from its windows.');
@@ -217,19 +240,32 @@ async function uninstall() {
   if (entry) say(`Removed the logon entry: ${entry}`);
   const dir = installDir();
   if (path.basename(dir) === NAME && existsSync(dir)) {
-    rmSync(dir, { recursive: true, force: true });
+    removeTree(dir);
     say(`Deleted ${dir}`);
   }
-  const appDir = path.join(appResourcesDir(), 'app');
+  const resources = appResourcesDir();
+  try {
+    if (restoreArchive(resources)) say("Restored the app's own app.asar.");
+  } catch (err) {
+    say(`Could not restore app.asar now (${err.code || err.message}): close Antigravity and run uninstall again.`);
+  }
+  removeLegacyArchive(resources);
+  const appDir = path.join(resources, 'app');
   if (existsSync(appDir)) {
-    rmSync(appDir, { recursive: true, force: true });
-    say(`Removed native installation at ${appDir}. Restored stock app.asar.`);
+    if (open) {
+      // the running app loads its windows from this folder: leave it, unpatched
+      unpatchApp(appDir);
+      say(`Took the themes out of ${appDir}. Close Antigravity and run uninstall again to delete that copy of the app.`);
+    } else {
+      removeTree(appDir);
+      say(`Removed ${appDir}: Antigravity runs from its own app.asar again.`);
+    }
   }
   say('Done. Antigravity keeps your last theme choice in its own storage; it has no effect without this tool.');
 }
 
 async function on() {
-  const results = await evaluateEverywhere(pageScript(ROOT));
+  const results = await evaluateEverywhere(scriptFor({ page: pageScript(ROOT), frame: frameScript(ROOT) }));
   const ok = results.filter((r) => !r.error).length;
   say(`Applied to ${ok} window(s).${await running() ? '' : ' Without the background process it lasts until a window reloads; "install" makes it permanent.'}`);
 }
@@ -257,17 +293,22 @@ async function theme() {
 }
 
 async function status() {
+  const resources = appResourcesDir();
+  const app = appState(resources);
+  const native = app.stamp && app.extractedVersion === app.appVersion;
+  const keeper = existsSync(path.join(pluginDir(), 'sidecars', 'keeper', 'sidecar.json'));
+  say(`Native:      ${native ? `patched (build ${app.stamp.build}, Antigravity ${app.appVersion})` : app.stamp ? `outdated (made for ${app.extractedVersion}, Antigravity is ${app.appVersion})` : 'no'}`);
+  say(`Keeper:      ${keeper ? pluginDir() : 'no'}`);
   const dir = installDir();
   let installed = null;
   try { installed = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8')).version; } catch { /* not installed */ }
-  say(`Installed:   ${installed ? `${installed} in ${dir}` : 'no'}`);
-  say(`At logon:    ${hasAutostart() ? autostartFile() : 'no'}`);
+  say(`Background:  ${installed ? `${installed} in ${dir}` : 'not installed'}${hasAutostart() ? `, at logon (${autostartFile()})` : ''}`);
   const state = await running();
-  say(`Background:  ${state ? `running (process ${state.pid}, version ${state.version})` : 'not running'}`);
+  if (state) say(`             running (process ${state.pid}, version ${state.version})`);
   try {
     const port = readPort();
-    const results = await evaluateEverywhere(PROBE_SCRIPT, port);
-    say(`Antigravity: running, port ${port}, ${results.length} window(s)`);
+    const results = await evaluateEverywhere(PROBE, port);
+    say(`Antigravity: running, port ${port}, ${results.length} window(s) and pane(s)`);
     for (const r of results) {
       const host = r.value ? JSON.parse(r.value) : null;
       say(`  ${host ? `themed (${host.theme})` : 'not themed'}  ${r.url}`);
@@ -276,10 +317,12 @@ async function status() {
     say(`Antigravity: ${existsSync(portFile()) ? err.message : `not running (no ${portFile()})`}`);
   }
   say();
-  if (installed && hasAutostart() && state) {
-    say('OK: installed and permanent.');
+  if (native && keeper) {
+    say('OK: installed natively, kept across Antigravity updates.');
+  } else if (installed && hasAutostart() && state) {
+    say('OK: installed with the background process.');
   } else {
-    say(`Not permanent. Fix it with: ${NPX} install`);
+    say(`Not permanent. Fix it with: ${NPX} install --native`);
     process.exitCode = 1;
   }
 }
@@ -289,16 +332,17 @@ function help() {
 
 Usage: ${NPX} <command>
 
-  install [--native]        Install the themes permanently.
-                            With --native: installs directly into Antigravity with ZERO background processes or servers.
-                            Default: copies themes to ${installDir()} and keeps them synced.
-  uninstall                 Remove the themes from Antigravity, the logon entry, and native app directory
+  install --native          Install the themes permanently, into Antigravity's own files: no background
+                            process, no logon entry. A small plugin puts them back after an Antigravity update.
+  install                   The older way: copies the themes to ${installDir()} and themes Antigravity
+                            from a background process started at logon.
+  uninstall                 Remove the themes, the plugin, the background process and its logon entry
   start                     Start the background process that themes every window (not permanent)
   stop                      Stop it (open windows keep the theme until they reload)
   on                        Apply the themes to the open windows once (not permanent)
   off                       Stop the background process and remove the themes from the open windows
   theme [key]               List the themes, or switch every window to one
-  status                    Show what is installed and running; exit code 1 if not permanent
+  status                    Show what is installed and running; exit code 1 if it is not permanent
   run [--dev]               Run the background process in this terminal (--dev reloads on file changes)`);
 }